Every Elixir Video Page

The source code is available on github.

Stats

• Total talks: 913
• Total conferences: 61
• Total speakers: 524

Conferences quick links

• Code Elixir LDN 2018
  
• Code Beam SF 2018
  
• Code Beam STO 2018
  
• Code Mesh London 2013
  
• Code Mesh London 2014
  
• Dayton Elixir 2014
  
• Developer Download 2014
  
• Elixir & Erlang Factory SF 2017
  
• Elixir & Phoenix Conf 2016
  
• Elixir.LDN 2016
  
• Elixir.LDN 2017
  
• ElixirConf 2014
  
• ElixirConf EU 2015
  
• ElixirConf EU 2016
  
• ElixirConf EU 2017
  
• ElixirConf EU 2018
  
• ElixirConf US 2015
  
• ElixirConf US 2017
  
• ElixirConf US 2018
  
• ElixirDaze 2016
  
• ElixirDaze 2017
  
• ElixirDaze 2018
  
• EMPEX 2016
  
• EMPEX 2017
  
• EMPEX LA 2018
  
• EMPEX NYC 2018
  
• Erlang DC 2013
  
• Erlang Factory 2014
  
• Erlang Factory 2015
  
• Erlang Factory Lite Berlin 2014
  
• Erlang Factory Lite Berlin 2016
  
• Erlang Factory Lite Kraków 2012
  
• Erlang Factory Lite London 2012
  
• Erlang Factory Lite Mexico City 2015
  
• Erlang Factory Lite Moscow 2012
  
• Erlang Factory Lite Munich 2013
  
• Erlang Factory Lite Vancouver 2012
  
• Erlang Factory SF 2012
  
• Erlang Factory SF 2013
  
• Erlang Factory SF 2014
  
• Erlang Factory SF 2015
  
• Erlang Factory SF 2016
  
• Erlang User Conference 2012
  
• Erlang User Conference 2013
  
• Erlang User Conference 2014
  
• GOTO 2014
  
• kievfprog 2013
  
• Linux.conf.au 2014
  
• London Erlang User Group 2014
  
• Lone Star Ruby Conference 2013
  
• Lonestar ElixirConf 2017
  
• Lonestar ElixirConf 2018
  
• NDC OSLO 2015
  
• Oredev 2012
  
• RailsConf 2014
  
• RedDotRubyConf 2014
  
• Ruby Conf 2013
  
• RuPy 2012
  
• Singapore Ruby Brigade Meetup 2013
  
• Solution Street hangout
  
• The Big Elixir 2018
  

Code Elixir LDN 2018

• # A shot of Absinthe: from zero to GraphQL in 40 minutes
  44:41 •  467 • Sam Davies
• # Absinthe Authentication
  03:28 •  73 • Jon Rowe
• # Bootcamp stories
  29:55 •  83 • Arjan Scherpenisse
• # Discovering distributed systems in Elixir
  32:38 •  585 • Maciej Kaszubowski
• # Elixir for curing product development pains?
  47:05 •  82 • Michael Krax
• # Elixir for the Long Haul
  37:26 •  260 • Powell Kinney
• # Fun with processes
  04:44 •  127 • Pawel Dawczak
• # Invariants are everything
  42:26 •  111 • Joseph Yiasemides
• # José Valim and friends answer most searched Elixir questions
  05:40 •  938 • José Valim • Keith Salisbury • Tetiana Dushenkivska • Andrea Leopardi
• # Managing externalities in a functional world
  23:58 •  101 • Evadne Wu
• # Mind your own business view controller
  26:02 •  295 • Peter Saxton
• # Overview & Challenges of building a Blockchain
  23:43 •  127 • P. Piwowarsky • G. Spasov
• # Pattern matching: The gateway to loving Elixir
  26:56 •  236 • Kate Travers
• # Saving the network by killing the network
  04:54 •  36 • Paul Wilson

Code Beam SF 2018

• # A GraphQL-on-Elixir Primer
  45:12 •  1454 • Bruce Williams
• # A Reflection on Building the WhatsApp Server
  47:05 •  2815 • Anton Lavrik
• # A Tour Through the Distributed System Zoo
  46:51 •  659 • Mariano Guerra
• # Aeternity: Scalable Smart Contracts
  25:35 •  657 • Erik Stenman
• # Arduino, Elixir And Nerves: A Deep Dive Into Firmata
  41:16 •  780 • Christopher Coté
• # Bridging The Physical and Blockchain World With Erlang
  25:09 •  378 • Andrew Thompson
• # Building and Integrating A Data Platform
  31:48 •  187 • Benoît Chesneau
• # CQRS and Event Sourcing
  24:30 •  2271 • Bernardo Amorim
• # Crypto + Concurrency
  34:06 •  203 • Anna Neyzberg
• # Designing Rich API Clients at Scale
  38:25 •  132 • Jeff Ching
• # Erlang In Action: Creating Scalable Edge Based Iot Solution
  45:18 •  549 • Murali Kashaboina
• # Fighting Authoritarianism With Blockchain And Blockweaves
  43:55 •  397 • Sam Williams
• # From Cloud to Edge Networks
  43:08 •  127 • Sébastien Merle
• # Gently Down the Stream
  19:07 •  191 • Geoffrey Lessel
• # Getting to Know Your Rabbit
  38:30 •  169 • Brett Cameron
• # High Performance Metrics Through Mutable Counters
  27:58 •  202 • Irina Guberman
• # Hype For Types: Using Dialyzer to bring type checking to your Elixir code
  29:57 •  388 • Emma Cunningham
• # Implementing Languages on the BEAM
  44:21 •  572 • Robert Virding • Mariano Guerra
• # Intro to Machine Learning
  45:44 •  413 • Jesse J. Anderson
• # Introducing Wrek: A Library For Executing Dependency Graphs
  18:17 •  152 • Richard Kallos
• # Is Security on Your Nerves
  45:21 •  128 • Paul Rogers
• # LPWAN and Cellular IoT Explained
  24:34 •  181 • Bryan Hughes
• # Learning Elixir Better through Collaboration and Giving Back
  43:59 •  174 • Mohnish Jadwani
• # Let it Be Hacked
  45:36 •  436 • Duncan Sparrell
• # Making It Lazy Never Evaluate Anything More Than Once
  42:55 •  219 • Simon Thompson
• # Metaprogramming - Programs that Write Programs
  41:42 •  241 • Jay Hayes
• # Mixing in Elixir to Build Search
  22:26 •  317 • Adrian Cruz
• # Next Generation SCADA
  42:27 •  182 • Brett Cameron • David Brinnen
• # Opaque Structures and Other Yerbas
  20:17 •  281 • Brujo Benavides
• # Packaging for Production
  42:49 •  186 • Anthony Molinaro
• # Quaff that potion saving $millions
  21:04 •  200 • Mike Watters
• # Quantum Computing Exposed - Schrödinger's Grumpy Cat
  43:13 •  132 • James Weaver
• # Release, Deploy, Monitor and Upgrade Elixir Services in Real World
  36:54 •  930 • Tian Chen
• # Releases and Elixir: Envisioning a more perfect union
  46:36 •  443 • Paul Schoenfelder
• # Spells, Hexes, and Charms Running your Own Private Package Service
  31:30 •  96 • Mark Allen
• # Taking Erlang Elixir to the Metal
  42:58 •  668 • Sonny Scroggin
• # Testing Tools for the Erlang Ecosystem
  51:37 •  278 • Kostis Sagonas
• # The Forgotten Ideas in Computer Science
  49:36 •  8747 • Joe Armstrong
• # The Hitchhiker's Guide to the Unexpected
  43:29 •  1613 • Fred Hebert
• # The Magic Behind Immutable Maps
  18:29 •  321 • Jean Rouge
• # Trusted Autonomy
  24:34 •  100 • Ben Marx
• # Understanding Erlang Term
  26:39 •  344 • Boshan Sun
• # Unreachable Code: A Conversation about Safety and Human Factors
  47:31 •  139 • Jessica DeVita
• # Unsung Heroes of the BEAM
  35:39 •  1973 • Miriam Pena
• # Update Elixir Core Dev Team
  14:10 •  583 • James Fish
• # Update OTP Team
  14:05 •  753 • Raimo Niskanen
• # Why Elixir Matters: A Genealogy of Functional Programming
  39:45 •  368 • Osa Gaius
• # Wide World of Actors
  44:05 •  1200 • Scott Lystig Fritchie
• # gen_statem - The Tool You Never Knew You Always Wanted
  38:19 •  905 • Raimo Niskanen
• # wxErlang & Faithful Representation
  39:28 •  340 • Robert Carbone

Code Beam STO 2018

• # A genealogy of Functional Programming
  24:54 •  109 • Osa Gaius
• # A gradual type system
  39:33 •  111 • Josef Svenningsson
• # A one minute talk summary
  01:21 •  36 • Peer Stritzinger • Adam Lindberg
• # A one minute talk summary
  00:47 •  70 • Simon Thompson
• # APRS-IS servers on the BEAM - amateur radio
  37:01 •  119 • Kenji Rikitake
• # Aeternity smart contracts
  33:30 •  210 • Erik Stenman • Tobias Lindahl
• # Beyond state machines: services as petri nets - Code BEAM STO
  33:37 •  283 • Jörgen Brandt
• # Boosting Erlang superpowers at WhatsApp
  39:42 •  895 • Anton Lavrik
• # Choosing which company to start
  33:36 •  130 • Jane Walderud
• # Clojure on the BEAM
  35:06 •  340 • Juan Facorro
• # Crypto + concurrency
  22:01 •  39 • Anna Neyzberg
• # Developer tools using the language server protocol
  24:05 •  96 • Vlad Dumitrescu
• # Ecto - database library for Elixir
  35:48 •  167 • Eric Meadows-Jönsson
• # Erlang in the sky with diamonds
  38:13 •  168 • Torben Hoffmann
• # Erlang: 20 years as open source
  28:46 •  101 • Ingela Anderton Andin
• # Erliot: monitoring and control of smart connected devices
  37:10 •  44 • Guy A Narboni
• # Evolution of garbage collector
  25:02 •  132 • Boris Kuznetsov
• # Expressive Power on the BEAM
  30:42 •  88 • Joseph Yiasemides
• # ForgETS: a globally distributed database
  37:21 •  465 • Mikhail Vorontsov
• # From a web application to a distributed system
  39:08 •  261 • Gianluca Padovani
• # Gen_statem - the tool you never knew you always wanted
  40:36 •  248 • Raimo Niskanen
• # Getting to the BEAM, without going through Erlang
  24:33 •  236 • Kofi Gumbs
• # How Cisco is using Erlang for intent-based networking
  28:21 •  566 • Johan Bevemyr
• # How Elixir changed the Ukrainian healthcare system
  21:03 •  177 • Alex Troush
• # Implementing Languages on the BEAM
  17:03 •  100 • Robert Virding
• # Logger a new API for logging
  29:44 •  97 • Kenneth Lundin
• # Making It Lazy: never evaluate anything more than once
  39:58 •  201 • Simon Thompson
• # News from the OTP team
  19:20 •  266 • Kenneth Lundin
• # No(de) discovery without DNS & EPMD
  23:09 •  77 • Timmo Verlaan
• # Open Source: The Third Decade
  52:51 •  42 • Simon Phipps
• # Opencensus: a stats collection and distributed tracing framework
  18:42 •  235 • Iliia Khaprov
• # Optimising for the BEAM
  35:17 •  212 • Michał Muskała
• # Property-Based Testing in Blockchain and P2P Networks
  18:10 •  179 • Thomas Arts
• # Prototyping with new OTP 21 API
  32:19 •  256 • Peer Stritzinger • Adam Lindberg
• # Raxx: refined web development
  27:36 •  119 • Peter Saxton
• # Researching with Erlang
  30:59 •  154 • Natalia Chechina
• # Riak 3.0 and efficient anti-entropy
  37:24 •  243 • Martin Sumner
• # Sagas of Elixir
  16:34 •  223 • Andrew Dryga
• # Simple is beautiful: building an SLA monitoring tool at PagerDuty
  26:02 •  67 • Aish Dahal
• # Stateful webhooks: what are they good for?
  23:25 •  97 • Nathan Herald
• # Taking it to the metal
  38:56 •  103 • Sonny Scroggin
• # The Robots are Coming: Failure is not an Option!
  19:25 •  62 • Kevin Hammond
• # The quest for the best IDE
  16:36 •  296 • Csaba Hoch
• # Thin layer or how to connect it all
  16:53 •  58 • Pawel Antemijczuk
• # Unsung Heroes of the BEAM
  28:58 •  237 • Miriam Pena
• # Update: Elixir core dev team
  13:10 •  111 • Andrea Leopardi
• # Using Barrel to build your own P2P data platform
  20:24 •  58 • Benoît Chesneau
• # Using Erlang in Blockchain Development
  41:00 •  131 • Ulf Wiger
• # What are poll sets and why they matter
  24:57 •  136 • Peter Gömöri
• # What do you mean I have to secure this thing?
  30:05 •  81 • Chad Gibbons

Code Mesh London 2013

• # Ecto: A language integrated query for Elixir
  41:11 •  6554 • José Valim

Code Mesh London 2014

• # Connecting Things Together is Really Difficult but it Could and Should be Rather Easy
  52:39 •  1608 • Joe Armstrong
• # Implementing Languages on the BEAM
  49:59 •  1009 • Robert Virding
• # Tackling Dirty Jobs with Erlang's Schedulers
  46:41 •  994 • Steve Vinoski

Dayton Elixir 2014

• # Taming the Command Line and Erlang Ports
  72:22 •  1596 • Alexei Sholik

Developer Download 2014

• # An Overview on Elixir
  05:17 •  642 • Paul Schoenfelder
• # Resources & Libraries
  07:21 •  715 • Paul Schoenfelder
• # Show me the code!
  12:12 •  1472 • Paul Schoenfelder

Elixir & Erlang Factory SF 2017

• # 5 Hobby Projects
  43:53 •  4486 • Joe Armstrong
• # Alpaca Static Typing on the BEAM
  45:35 •  1638 • Jeremy Pierre
• # Billions of Events Per Day with Elixir
  41:35 •  2915 • Danni Friedland
• # Building Devices with Elixir Erlang using Nerves
  40:30 •  2541 • Justin Schneck
• # Building a web app in Erlang - yes you heard me right I said Erlang not Elixir
  41:15 •  16327 • Garrett Smith
• # Chaos at Netflix
  42:12 •  1813 • Casey Rosenthal
• # Debugging Code that Crashes the BEAM
  37:52 •  388 • Richard Kallos
• # Elm and Phoenix Two FP Flavors That Taste Great Together
  47:52 •  5935 • Josh Adams
• # Empowering devices for IoT with Erlang and FPGA
  44:55 •  1725 • Irina Guberman
• # Erlang Performance Lab
  47:43 •  1729 • Michał Ślaski
• # Flexible Elixir
  32:44 •  1229 • Claudio Ortolina
• # From Front End to Full Stack with Elixir & Phoenix
  42:33 •  2314 • Lauren Tan
• # How Elixir Made Us Better Programmers
  29:53 •  1026 • Ari Lerner • Anna Neyzberg
• # How to Design a Software Library
  38:14 •  697 • Andrea Leopardi
• # Instrumenting and Testing High Performance Switching Fabric for IoT
  38:36 •  353 • Vladan Djakovic
• # Instrumenting the World with the BEAM
  45:49 •  728 • Christopher Coté
• # Keynote - Piecemeal Into Space Reliability Safety and Erlang Principles
  57:29 •  1046 • Brian Troutwine
• # Keynote: Welcome Inside the Head of Larry Wall
  51:42 •  3950 • Joe Armstrong • Larry Wall
• # Lightning Talk: Code like it's 1999
  01:32 •  324 • Dave Thomas
• # Lightning Talk: Exploiting Constant Pool with Merl
  04:18 •  241 • Yoshihiro Tanaka
• # Lightning Talk: Just-Right Consistency: Closing The CAP Gap
  03:15 •  217 • Christopher Meiklejohn
• # Lightning Talk: Mr White Erlang Interpreter for Whitespace
  05:15 •  239 • Derek Brown
• # Lightning Talk: Plug static Is directory listing module for Plug Phoenix
  03:16 •  141 • Kenji Rikitake
• # Lightning Talk: Smashing Passivity
  06:10 •  127 • Kevin Smith
• # Lightning Talk: Talking to Machine
  05:28 •  150 • Robert Beene
• # Lightning Talk: This is the wrong tool
  04:30 •  253 • \'Ley Missailidis
• # Lightning Talk: ehelper Erlang documentation in iex
  08:04 •  168 • Booker Bense
• # Lisp Machine Flavors for LFE implementing objects on Erlang OTP
  42:17 •  806 • Robert Virding
• # Loquat A Design for Large Scale Distributed Applications
  46:30 •  623 • Christopher Meiklejohn
• # News From The OTP Team
  13:17 •  1159 • Lukas Larsson
• # Orchestrating Chaos Applying Database Research in the Wild
  43:58 •  813 • Peter Alvaro
• # Realtime Data Pipelines with Elixir GenStage
  45:39 •  4096 • Peter Hastie
• # Responding to Cyber Attack at Machine Speed
  40:34 •  397 • Duncan Sparrell
• # Stateful Web Apps with Phoenix and OTP
  47:58 •  3398 • Hannah Howard
• # The ABCs of OTP
  42:20 •  102 • Jesse J. Anderson
• # Tracing JIT Compiler
  44:12 •  1401 • Lukas Larsson
• # Transforming Programming
  46:46 •  9017 • Dave Thomas
• # Wireless Embedded Erlang Applications with Grisp Hardware Boards and Toolchain
  45:03 •  1075 • Peer Stritzinger

Elixir & Phoenix Conf 2016

• # Abstractions: A Tale of Keys and Values
  46:21 •  591 • Ernie Miller
• # Building "learn to touch type" glove with Elixir and Arduino
  33:00 •  946 • Tetiana Dushenkivska
• # Building Available and Partition Tolerant Systems with Phoenix Tracker
  45:04 •  828 • Gabi Zuniga
• # Building Umbrella Project
  37:29 •  6273 • Wojtek Mach
• # Closing Keynote
  42:45 •  2901 • Boyd Multerer
• # Code Spelunking for Knowledge and Profit
  28:01 •  1220 • Brian Cardarella
• # Collaborative Music with Elm and Phoenix
  43:50 •  1684 • Josh Adams
• # Concurrent Feature Testing with Wallaby
  38:12 •  669 • Chris Keathley
• # Debugging Techniques in Elixir
  31:21 •  2325 • Erich Kist
• # Dialyzer: Optimistic Type Checking for Erlang and Elixir
  48:58 •  3045 • Jason Voegele
• # Edgelixir: Distributed Graph Processing in Elixir
  34:53 •  931 • Nathan Lapierre
• # Elixir in Elixir
  46:13 •  1278 • Jay Hayes
• # From Front End to Full Stack with Elixir and Phoenix
  34:21 •  9986 • Lauren Tan
• # Giving up the Object-Oriented Ghost
  38:48 •  3683 • Morgan Laco
• # Implementing Binary Protocols with Elixir
  41:03 •  1419 • Ole Michaelis
• # Keynote
  66:04 •  10187 • José Valim
• # Keynote
  58:21 •  6344 • Chris McCord
• # Leveling Up With Ecto
  36:50 •  4756 • Darin Wilson
• # Measuring your Elixir Application
  41:58 •  2063 • Renan Ranelli
• # Migrating an Invoicing System to Elixir/Erlang
  45:22 •  987 • Norberto Ortigoza
• # Nerves + Phoenix Saves a Father's Sanity!
  37:51 •  1582 • Joel Byler
• # Nerves: Connected Beyond the Node
  43:42 •  832 • Justin Schneck
• # No REST for the Wicked. Building a GraphQL
  38:02 •  3100 • Ben Wilson
• # Painless Test Driven Development with Elixir and Phoenix
  38:34 •  5125 • Kat Tornwall
• # Phoenix Beyond the Browser - Realtime Applications with Phoenix and Swift
  43:04 •  3883 • David Stump
• # Refactoring Techniques for Elixir, Ecto, and Phoenix
  37:51 •  3467 • Gary Rennie
• # Selling Food With Elixir
  45:14 •  7394 • Chris Bell
• # String Theory
  37:04 •  1910 • Nathan Long • James Edward Gray II
• # The Joy of Connecting Elixir to the Physical World
  46:05 •  3228 • Frank Hunleth
• # The future of Deployment in Elixir
  43:48 •  1559 • Paul Schoenfelder
• # The new Calendar Types in Elixir 1.3
  35:19 •  922 • Lau Taarnskov
• # WebRTC and Phoenix, when μ Seconds aren't Fast Enough
  37:04 •  3277 • Jason Stiebs
• # pg2 and You: Getting Distributed with Elixir
  34:35 •  3754 • Eric Entin

Elixir.LDN 2016

• # "Learn to Touch Type" Glove
  39:45 •  492 • Tetiana Dushenkivska
• # Build Your Own Elixir
  45:38 •  908 • Louis Pilfold
• # Building a search engine: my introduction to functional programming
  05:18 •  734 • Sophie Rimington-Pounder
• # Controller Control: Designing Domains for Web Applications
  40:18 •  2275 • Gary Rennie
• # Elixir & DNSimple
  04:57 •  595 • Anthony Eden
• # GenStage in the Kitchen
  39:45 •  2711 • Claudio Ortolina
• # Heisenbug
  05:18 •  431 • Simon Woolf
• # Intro to Webpack and Code-splitting for Phoenix
  06:31 •  579 • Svilen Gospodinov
• # Introducing Raxx, an Elixir Webserver Interface
  05:38 •  692 • Peter Saxton
• # Moving to Elixir from Ruby
  38:49 •  684 • Marni Cohen • Gabriella Chronis
• # Pilgrim's Progress to the Promised Land
  52:25 •  948 • Robert Virding
• # Running Elixir on a Raspberry Pi
  33:18 •  2698 • Ju Liu
• # Thumbnail Generation in Elixir/Erlang with libVIPS
  06:17 •  585 • Evadne Wu
• # Where the Wild Things Are
  41:25 •  590 • Johnny Winn

Elixir.LDN 2017

• # Elixir Umbrella: Microservices or Majestic Monolith?
  42:17 •  6307 • Georgina McFadyen
• # Getting Pretty Serious
  25:24 •  1376 • Louis Pilfold
• # HTTP/2 Plug to Phoenix, Cowboy Too
  43:01 •  1439 • Gary Rennie
• # How We Created Elixir University Course
  20:33 •  716 • Nikolay Tsvetinov
• # How to Sell Elixir
  19:39 •  1061 • Evadne Wu
• # Introduces Her Talk
  00:54 •  490 • Brooklyn Zelenka
• # Profiling and Tracing for all with Xprof
  26:15 •  731 • Péter Gömöri
• # Stepping into a New Era: Injecting Elixir in an Existing System
  27:15 •  1196 • Andrea Leopardi
• # The Feature That No One Knew About in Elixir 1.5
  36:11 •  7283 • José Valim
• # The Journey From Ruby to Elixir
  01:40 •  406 • Louis Pilfold
• # Witchcraft: Monads for the Working Alchemist
  44:26 •  2722 • Brooklyn Zelenka
• # Women in the Coding Industry
  01:43 •  467 • Georgina McFadyen
• # Working with HTTP/2 in Elixir
  42:11 •  1585 • Peter Saxton

ElixirConf 2014

• # Elixir - Evaluating Performance of Language
  28:34 •  1619 • Filipe Varjão
• # Elixir Elevated
  43:00 •  1123 • Greg Vaughn
• # Elixir in an Enterprise Telecommunications Product
  49:29 •  1345 • Stephen Pallen
• # Erlang Rationale
  49:27 •  2284 • Robert Virding
• # Fear and the Evolution of Languages
  45:25 •  1084 • Bruce Tate
• # Hex - How it was built
  45:59 •  1343 • Eric Meadows-Jönsson
• # Introduction to Elixir for Rubyists
  50:38 •  4056 • Josh Adams • Robby Clement
• # Keynote: Elixir
  59:32 •  9204 • José Valim
• # Keynote: Think Different
  55:48 •  19122 • Dave Thomas
• # OTP In Production: The Nitty-Gritty Details Of Game Servers
  27:34 •  5436 • Martin Schürrer
• # Rise of The Phoenix - Building an Elixir Web Framework
  44:13 •  15252 • Chris McCord
• # The Excitement of Elixir
  32:20 •  1143 • Devin Torres
• # The First Few Sips
  32:58 •  1762 • Richard Bishop
• # Thinking in a Highly Concurrent, Mostly-functional Language
  49:09 •  6828 • Francesco Cesarini
• # Writing Command Line Applications with Elixir
  32:25 •  3422 • James Smith

ElixirConf EU 2015

• # Building Lego Robots with Elixir
  48:07 •  1292 • Torben Hoffmann
• # Chat Bot: A Practical Walkthrough of the powerful Features Elixir/Erlang/OTP
  32:48 •  2782 • Jeff Weiss
• # Collaborative Web-based Tetris with Phoenix
  48:30 •  2170 • Josh Adams
• # Ecto
  52:17 •  1701 • Eric Meadows-Jönsson
• # Fast Continuous Deployment of an Elixir Gameserver
  30:04 •  3001 • Martin Kavalar
• # High Availability
  39:30 •  1306 • Saša Jurić
• # Individualized Content at Web-scale
  57:32 •  4004 • Michael Schaefermeyer
• # Keynote: Phoenix Takes Flight
  51:27 •  5352 • Chris McCord
• # Keynote: What's Ahead for Elixir?
  70:52 •  6089 • José Valim
• # Lessons from Erlang VM
  27:08 •  2889 • Michał Ślaski
• # One project rebuilt 4 times
  37:35 •  1089 • Miloš Mošić • Marco Herbst
• # QuickCheck for Elixir - Generate Tests Automatically
  43:06 •  1789 • Thomas Arts
• # Rewriting a Ruby application in Elixir
  44:49 •  2020 • Claudio Ortolina
• # Scale, Manage and Prevent!
  34:22 •  639 • Francesco Cesarini • Viktória Fördős

ElixirConf EU 2016

• # Building Multiplayer Games with Phoenix and Phaser
  34:48 •  6054 • Keith Salisbury
• # Concurrent and Resilient Connections to Outside the BEAM
  35:27 •  1266 • Andrea Leopardi
• # Credo - Analysing AST for Fun and Profit
  37:00 •  1313 • René Föhring
• # Discovering Processes
  41:06 •  4108 • Saša Jurić
• # Ecto - the Past, the Present, the Future
  34:54 •  2534 • Michał Muskała
• # Enhanced Embedded Systems with Nerves
  56:12 •  5036 • Justin Schneck
• # From a Ruby on Rails Monolith to Elixir and Elm Microservices
  46:04 •  4435 • Volker Rabe
• # How to Build a Slack-Controlled, Saxophone-Playing Robot
  39:02 •  891 • Paul Wilson
• # Phoenix 1.2 and Beyond
  54:13 •  11738 • Chris McCord
• # Phoenix Is Not Your Application
  30:03 •  6497 • Lance Halvorsen
• # Phoenix on Riak_Core
  38:18 •  3214 • Ben Tyler
• # Scaling Distributed Erlang
  47:24 •  2435 • Zandra Norman
• # Securing Elixir Applications
  42:53 •  1870 • Bram Verburg
• # The Road to 2 Million Websocket Connections in Phoenix
  40:02 •  2961 • Gary Rennie
• # Three Games In Elixir
  37:59 •  2182 • Roope Kangas
• # What's Ahead for Elixir?
  53:04 •  16056 • José Valim

ElixirConf EU 2017

• # A Practical Guide to Elixir Protocols
  32:10 •  5519 • Kevin Rockwood
• # Always Available
  44:01 •  1344 • Claudio Ortolina
• # Background Processing with RabbitMQ
  47:06 •  973 • Tatsuya Ono
• # Building a Graphical IDE in Elm/Purescript
  40:47 •  1909 • Claudia Doppioslash
• # Building a Scalable, Distributed Backend for Mobile Games
  46:18 •  3830 • Petri Kero
• # Designing a Multi-Language Live Programming Tool With Phoenix and Genstage
  37:33 •  1032 • Andrea Amantini
• # Elixir and Money
  40:58 •  3908 • Tomasz Kowal
• # ElixirConf EU 2017 Keynote
  56:47 •  10636 • José Valim
• # Fly like an Eagle
  40:19 •  964 • Loic Vigneron
• # GraphQL in Practice
  43:58 •  1057 • Bruce Williams • Ben Wilson
• # Just Enough Plug to Build a Web server
  39:04 •  1427 • Ole Michaelis
• # Keeping Code Consistent
  39:26 •  1017 • Ben Marx
• # Machine Learning with Elixir and Phoenix
  41:43 •  6223 • Eric Weinstein
• # Nervous System - Nerves Clustering Using Your Own Distribution
  39:46 •  3849 • Timmo Verlaan
• # One and Only One Process in a Distributed System
  26:51 •  1110 • Nathan Herald
• # Phoenix - Gauging Progress
  49:07 •  5492 • Chris McCord
• # Refactoring Elixir - Lessons Learned from a Year on Exercism.Io
  35:38 •  2843 • Devon Estes
• # Testing Web Services with QuickCheck
  44:52 •  748 • Thomas Arts
• # The Age of Elixir
  48:30 •  1028 • Keith Salisbury • Tetiana Dushenkivska
• # The Best Library I Ever Designed
  30:35 •  1199 • Andrea Leopardi
• # Visual Reasoning and Mental Maps in Elixir
  34:41 •  1915 • Dániel Vámosi
• # Wobserver: Easy to Integrate Monitoring and Debugging
  39:25 •  979 • Ian Luites

ElixirConf EU 2018

• # Building a Task Queue System
  61:28 •  1228 • Evadne Wu
• # Building communication platforms for IoT
  38:41 •  606 • Troels Brødsgaard
• # Building videochat with Elixir and Phoenix
  42:32 •  2273 • Anil Wadghule
• # Coupling Data and Behaviour
  33:14 •  787 • Guilherme de Maio
• # ElixirConf EU 2018 Highlights Video
  03:32 •  1132 •
• # Event-driven architectures in Elixir
  36:07 •  2784 • Maciej Kaszubowski
• # Fleet management solution for autonomous vehicles
  46:58 •  814 • Serge Boucher
• # Going low level with TCP sockets and :gen_tcp
  39:51 •  1309 • Orestis Markou
• # He Has the Nerve
  43:40 •  762 • Justin Schneck
• # Instrumenting mayhem: functional chaos engineering
  33:51 •  400 • Szymon Mentel
• # Introducing HDD: Hughes Driven Development
  57:09 •  2149 • José Valim
• # Knee Deep Into P2P
  39:09 •  892 • Fernando Mendes
• # Let's do Elixir and Phoenix together
  45:15 •  8195 • Chris McCord
• # Orchestrating Consumers and Producers Like an Octopus
  27:04 •  565 • Jusabe Guedes
• # Phoenix and the World of Tomorrow
  34:47 •  2431 • \'Ley Missailidis
• # Property-based Testing is a Mindset
  44:59 •  1961 • Andrea Leopardi
• # Rewriting a legacy application in Elixir
  43:55 •  2438 • Raphael Costa
• # Robust Data Processing Pipeline with Elixir and Flow
  41:13 •  1259 • Laszlo Bacsi
• # SOLID Elixir
  45:59 •  4321 • Georgina McFadyen
• # SSH server/client in Erlang
  42:15 •  998 • Milad Rastian
• # Ship Your Code While It's Hot
  42:24 •  2231 • Albert Zak
• # State and distributed data structures
  36:31 •  801 • Arkadiusz Gil
• # The Phoenix Boot Process
  49:16 •  715 • Xavier Noria

ElixirConf US 2015

• # A Deep Dive into Binaries
  33:15 •  1116 • Chris Maddox
• # BEAMing with Joy
  39:04 •  1572 • Steven Proctor
• # Composable Queries with Ecto
  25:42 •  1951 • Drew Olson
• # Elixir Should Take Over the World
  58:31 •  27623 • Jessica Kerr
• # Elixir in the Browser
  28:50 •  1780 • Bryan Joseph
• # Embedded Elixir in Action
  42:59 •  6303 • Garth Hitchens
• # Expert Panel: Elixir Fountain Live!
  39:23 •  1047 • Johnny Winn • José Valim • Alan Gardner • Lennart Fridén • Eric Meadows-Jönsson • Chris McCord • Bryan Joseph
• # Gettext for Elixir - getting serious at compile time
  27:39 •  1005 • Andrea Leopardi
• # How To Contribute to Elixir and Phoenix
  31:28 •  1359 • Wendy Smoak
• # Interoperability in Elixir: Dealing With the World Outside of the Beam
  30:38 •  1403 • James Smith
• # Into Production
  49:03 •  2728 • Jamie Winsor
• # Keynote
  52:14 •  8975 • José Valim
• # Mastering date/time handling with Elixir
  34:45 •  1525 • Lau Taarnskov
• # OTP Has Done It
  36:05 •  4985 • Nick DeMonner
• # Streams, External Services, and OTP
  27:26 •  2167 • Ben Wilson
• # The Pendulum
  40:13 •  3591 • Bruce Tate
• # The road to intellij-elixir 1.0.0
  52:57 •  1950 • Luke Imhoff
• # Virtually Instructional
  29:55 •  1168 • Lennart Fridén
• # What's Next for Phoenix
  33:08 •  4335 • Chris McCord

ElixirConf US 2017

• # Back on Your Feet
  37:28 •  833 • Claudio Ortolina • Discussion
• # Baseball and How To Sell Elixir
  04:39 •  270 • David Schainker
• # Building Realtime Mobile Apps with React Native and Elixir
  36:42 •  2020 • Osa Gaius • Discussion
• # Building an Artificial Pancreas with Elixir and Nerves
  41:26 •  3530 • Tim Mecklem • Discussion
• # Building an Open Source, Real Time Forum with Phoenix and Elm
  40:56 •  3485 • Josh Adams • Discussion
• # Cajoling the Bird: How we squeezed more out of Phoenix PubSub
  37:09 •  1430 • Simon Zelazny • Discussion
• # Closing Keynote
  48:16 •  5097 • Chris McCord • Discussion
• # Databaseless
  05:04 •  674 • Norberto Ortigoza
• # Day 1 Keynote
  68:07 •  7588 • Justin Schneck • Discussion
• # Day 2 Morning Keynote
  65:42 •  4921 • José Valim • Discussion
• # Demoing Thesis - a Phoenix CMS
  05:30 •  605 • Jamon Holmgren
• # Don't Write Macros But Do Learn How They Work
  34:09 •  2699 • Jesse J. Anderson • Discussion
• # Dr. ErlangOTP or How I Learned to Stop Worrying and Love `disk log`
  39:23 •  1369 • Eric Entin • Discussion
• # Elixir + Neo4j
  29:59 •  1174 • Regina Imhoff • Discussion
• # Elixir Native UI
  45:41 •  6061 • Boyd Multerer • Discussion
• # Elixir Power Tracing
  48:21 •  1264 • Gabi Zuniga • Discussion
• # Elixir The Toyota Way
  31:05 •  2307 • Powell Kinney • Discussion
• # Elixir Tips: A Year of Tiny Explosions
  05:37 •  385 • Rockwell Schrock
• # Elixir as a first language
  35:10 •  831 • Alexis Huefner • Discussion
• # Elixir by the Bellyful
  43:11 •  4547 • Bryan Hunter • Discussion
• # Elixir with Kafka
  24:28 •  2629 • Mathew Gardner • Discussion
• # ElixirBridge How Do We Shape Community
  35:17 •  405 • Anna Neyzberg • Discussion
• # Embedded Elixir for Monitoring the Built Environment
  40:38 •  1113 • Christopher Coté • Discussion
• # HTTP 2 Plug to Phoenix Cowboy too
  58:04 •  1089 • Gary Rennie • Discussion
• # Idea Scaling
  41:07 •  473 • Hannah Howard • Discussion
• # Implementing a MQTT client in Elixir
  35:02 •  1212 • Martin Gausby • Discussion
• # Its Better Unstated
  37:30 •  1150 • TJ Stankus • Discussion
• # Keep an Eye on the Sky with Nerves and Phoenix
  38:42 •  1956 • Jeff Smith • Discussion
• # Lambda Calculus in 5 mintues
  06:13 •  493 • Mohd Maqbool Alam
• # Live APIs with GraphQL Subscriptions
  41:09 •  4672 • Bruce Williams • Ben Wilson • Discussion
• # Managing Tables With Elixir and OTP
  30:16 •  1760 • Robert Beene • Discussion
• # My Journey from Go to Elixir
  36:17 •  6438 • Veronica Lopez • Discussion
• # OpenApi and Elixir
  04:11 •  502 • Jeff Ching
• # Patience Using Phoenix Presence in a Primary Care Clinic
  35:50 •  1960 • Keith Gautreaux • Discussion
• # Phoenix after 100000 lines
  40:24 •  6587 • Renan Ranelli • Discussion
• # Plugging the Security Holes in Your Phoenix Application
  37:28 •  1763 • Griffin Byatt • Discussion
• # QR Code in Elixir
  01:39 •  365 • Boshan Sun
• # Realtime Vehicle Tracking with Elixir and Phoenix
  38:42 •  3566 • James Smith • Discussion
• # Scaling up Elixir at TpT
  31:10 •  655 • Shanti Chellaram • Discussion
• # Speeding up your program with Steroids
  09:24 •  259 • John Wahba
• # Streaming Video with Elixir
  20:07 •  1892 • John Wahba • Discussion
• # The Power of Zero
  40:49 •  838 • Andrew Forward • Discussion
• # Thinking In Ecto
  35:25 •  7572 • Darin Wilson • Discussion
• # Well Behaved Native Implemented Functions for Elixir
  37:53 •  933 • Andrew Bennett • Discussion
• # Why Elixir is perfect for taming the monolith
  05:10 •  553 • Scott Ribe
• # Working with legacy databases in Ecto
  33:29 •  842 • Geoffrey Lessel • Discussion
• # Writing an Editor in Elixir
  38:07 •  1389 • Ian Duggan • Discussion
• # XProf
  04:07 •  212 • Wojciech Gawroński
• # rDDD & Perhap: reactive Domain Driven Design
  37:41 •  3982 • Rob Martin • Discussion

ElixirConf US 2018

• # 4 years of small learnings
  05:37 •  332 • Chris Ertel • Discussion
• # A Deep Dive Into Hex
  41:35 •  452 • Todd Resudek • Discussion
• # ACRUMEN The Six Key Aspects of Software Quality
  04:51 •  246 • Dave Aronson • Discussion
• # Architecting Flow in Elixir: From Leveraging Pipes to Designing Token APIs
  42:05 •  1308 • René Föhring • Discussion
• # Behavior Trees and Battleship: Tapping into the Power of Advanced Data Structures
  35:13 •  740 • Jeff Schomay • Discussion
• # Beyond Command and Response Chatbot
  35:04 •  351 • Fahad Almusharraf • Discussion
• # Breaking Down the User Monolith
  33:34 •  1717 • Zach Porter • Discussion
• # Building Video Chat with Elixir & Phoenix
  41:02 •  1035 • Anil Wadghule • Discussion
• # Building a Stateful Web Application with Elixir
  35:40 •  2237 • Enio Lopes • Discussion
• # Code highlighting with elixir
  02:42 •  325 • Jeffrey Gillis • Discussion
• # Deconstructing Korean with Elixir
  04:13 •  241 • Javier Evans • Discussion
• # Did You Hear That Wind
  37:45 •  644 • Frank Kumro • Discussion
• # Docker and OTP Friends or Foes
  38:53 •  3546 • Daniel Azuma • Discussion
• # Down the Memory Lane: a Tale of Memory Leaks
  27:04 •  427 • Guilherme de Maio • Discussion
• # ETS caching
  04:42 •  373 • Doug Wright • Discussion
• # Elixir at a Walking Pace
  44:58 •  1531 • Lance Halvorsen • Discussion
• # Elixium Blockchain Meets OTP
  04:39 •  402 • Alex Dovzhanyn • Discussion
• # Empirical Monkeys A Practitioner’s Take on
  38:40 •  580 • Rafal Studnicki • Simon Zelazny • Discussion
• # Erlang/OTP: What’s in the Box?
  38:26 •  1371 • João Britto • Discussion
• # Event Sourcing in Real World Applications: Challenges, Successes and Lessons Learned
  40:34 •  2283 • James Smith • Discussion
• # ExVenture a MUD Server
  03:02 •  336 • Eric Oestrich • Discussion
• # Exchange of Crypto Coins
  24:46 •  349 • Anna Neyzberg • Discussion
• # Flux. Moving towards a full Elixir web stack
  03:40 •  475 • Chris Freeze • Discussion
• # Going Full Circle
  57:50 •  16939 • Chris McCord • Discussion
• # Going Multi-Node
  40:42 •  1247 • Eric Oestrich • Discussion
• # Growing Applications and Taming Complexity
  42:09 •  1667 • Aaron Renner • Discussion
• # Handling Success: Development and Deployment Beyond Hello World
  36:33 •  654 • Jerel Unruh • Discussion
• # Interfacing with Machine Learned Models
  33:04 •  533 • Mathew Gardner • Discussion
• # Introducing New Relic's Open Source Elixir Agent
  03:04 •  352 • Vince Foley • Discussion
• # Introducing Politilounge
  04:53 •  198 • Andrew Accuardi • Christopher Krailo • Discussion
• # Introducing Scenic - A Functional UI Framework
  42:23 •  7740 • Boyd Multerer • Discussion
• # Kernel functions you'll want to start using
  04:06 •  473 • Moxley Stratton • Discussion
• # Keynote
  35:34 •  1801 • Justin Schneck • Discussion
• # Making a GraphQL Server with Absinthe & Dataloader
  30:02 •  1549 • Aaron Votre • Discussion
• # Meet Virtuoso The Chatbot Orchestration Framework Built with Elixir
  29:56 •  633 • Justus Eapen • Discussion
• # My first Nerves Project Bioreactor
  33:54 •  722 • David Schainker • Discussion
• # Picking Properties to Test in Property Based Testing
  37:42 •  762 • Michael Stalker • Discussion
• # Resources for BEAM Internals
  02:02 •  222 • Luke Imhoff • Discussion
• # Scaling Concurrency Without Getting Burned
  29:25 •  1511 • Alex Garibay • Discussion
• # Simple is Beautiful: Building an SLA tracking tool with Elixir/OTP
  38:00 •  370 • Aish Dahal • Discussion
• # Sustainable Testing
  35:02 •  607 • Andrew Bennett • Discussion
• # Take Your Time
  39:03 •  861 • Ben Marx • Discussion
• # Texas: Virtual DOM Library for Server Side V DOM
  32:52 •  1235 • Dan McGuire • Discussion
• # The Next Five Years
  57:55 •  7695 • José Valim • Discussion
• # Ticket to Fly Porting an Application from Rails to Phoenix
  31:43 •  653 • Catherine Zoller • Discussion
• # UX Design Practices for Real Time Apps
  38:54 •  789 • Bailer Miller • Tim Mecklem • Discussion
• # Understanding Elixir's (Re)compilation
  39:48 •  765 • Renan Ranelli • Discussion
• # Use goldorin to build absinthe ecto enabled GraphQL APIs
  05:01 •  352 • Tian Chen • Discussion
• # Using Elixir GenStage to Track Video Watch Progress
  42:54 •  935 • Emerson Macedo • Discussion
• # Using Elixir and OTP behaviors to monitor infrastructure
  29:55 •  854 • Jeffrey Gillis • Discussion
• # We went insane for Elixir
  05:37 •  538 • Dan Porter • Jeremy Dewar • Discussion
• # We're Just Getting Started. Our Three Years with Elixir
  33:14 •  537 • Maciej Kaszubowski • Discussion
• # Welcome Keynote
  57:55 •  1341 • José Valim • Discussion
• # You Can Never Debug the Code You Run, But You Can View the Code the Debugger is Running
  40:19 •  4029 • Luke Imhoff • Discussion

ElixirDaze 2016

• # Adventures in Robotics with Elixir
  48:16 •  1872 • Jean-François Cloutier
• # Building and Testing API Endpoints with Phoenix
  37:48 •  6358 • Brian Cardarella
• # Design by Contract in Elixir. "Let it crash" Meets "It shouldn't crash"
  28:18 •  1689 • Guillermo Iguaran
• # Explicit Elixir
  27:51 •  2916 • Paul Lamb
• # Learn Elixir: Building a Neural Network from Scratch
  32:27 •  7084 • Karmen Blake
• # Nerves - Getting Started, and the Road Ahead
  36:51 •  3366 • Garth Hitchens
• # New Heights
  48:43 •  4389 • Chris McCord
• # New Heights
  48:43 •  4389 • Chris McCord
• # Processing 2.7 million images with Elixir (vs Ruby)
  32:40 •  20227 • David Padilla

ElixirDaze 2017

• # BEER: Not Just for Your Devs
  26:15 •  262 • Maureen McElaney
• # Building Communities of Smart Things Takes Nerves
  44:03 •  673 • Jean-François Cloutier
• # Can Elixir Bring Down Phoenix?
  29:45 •  4672 • Ben Marx
• # Deploying Elixir
  37:26 •  2405 • Paul Lamb
• # Elixir With Erlang Solutions
  51:59 •  957 • Francesco Cesarini
• # Embrace the Database With Ecto
  41:05 •  2582 • Josh Branchaud
• # Get Cooking With Nerves
  36:28 •  1957 • Garth Hitchens
• # Its all About the Journey
  43:48 •  325 • Tetiana Dushenkivska • Keith Salisbury
• # Lets Generate Tests
  32:49 •  590 • Chris Keathley
• # Live Like a Hippy
  38:07 •  435 • Amos King
• # Macros
  26:18 •  703 • Jason Cummings
• # Observer Driven Design
  21:28 •  960 • Omid Bachari
• # Solid Ground
  31:31 •  6498 • Saša Jurić
• # Stronger Than Fear: Mental Health in the Developer Community
  42:32 •  556 • Ed Finkler
• # Tackling Authentication with Phoenix
  29:14 •  2279 • João Maura
• # The ABCs of OTP
  31:10 •  2334 • Jesse J. Anderson
• # Using Your Umbrella
  29:12 •  1524 • Chris Bell
• # Yesterday's Cargo
  41:24 •  3257 • Dave Thomas

ElixirDaze 2018

• # A Deep Dive Into Hex
  41:39 •  386 • Todd Resudek
• # Become a Test Whisperer: what are your tests are telling you?
  29:53 •  531 • Jeffrey Matthias
• # Build your very own web framework in Elixir
  32:10 •  1598 • German Velasco
• # Building Beautiful Systems with Phoenix contexts and Domain-Driven Design
  38:47 •  7586 • Andrew Hao
• # Consistent, Distributed Elixir
  40:57 •  6012 • Chris Keathley
• # Crypto + Concurrency
  42:01 •  522 • Anna Neyzberg
• # Don’t let it crash: safe and convenient error handling with Exceptional
  40:32 •  779 • Brooklyn Zelenka
• # Format Your Elixir Code Now
  41:04 •  631 • Jake Worth
• # Hardware without Hardware or Lightning without Lightning
  49:12 •  535 • Amos King
• # Is Security on Your Nerves?
  44:40 •  259 • Paul Rogers
• # Keynote
  31:39 •  2728 • Rob Conery
• # Making Noise
  42:09 •  529 • Ben Marx
• # Purify your web development with Raxx
  33:49 •  1195 • Peter Saxton
• # Taking Elixir to the Metal
  46:36 •  1005 • Sonny Scroggin
• # The Hitchhiker’s Guide to the Unexpected
  45:29 •  1516 • Fred Hebert
• # Why Elixir Matters: A Genealogy of Functional Programming
  38:34 •  1447 • Osa Gaius

EMPEX 2016

• # A Journey to the Center of the BEAM
  41:50 •  1420 • Brian Mitchell
• # Async Jobs in Phoenix
  19:23 •  2377 • George Guimarães
• # Code Generation in Elixir
  43:55 •  954 • Bryan Weber
• # Concurrency + Distribution = Scalability + Availability
  45:50 •  1385 • Francesco Cesarini
• # Giving Back, building your first package
  19:29 •  433 • Brian Cardarella
• # Letting the Phoenix Fly in Production
  18:38 •  1754 • Monica Hirst
• # Micropatterns: Learning to Reach Quickly for the Right Tool
  37:27 •  3853 • Cameron Price
• # Real World Elixir Deployment
  40:36 •  7621 • Pete Gamache
• # The Climb - Experiencing the Rise of Elixir from the Inside
  49:15 •  1177 • Bruce Tate
• # The Journey to Elixir in Production (at Scale)
  24:02 •  1546 • Brandon Richey

EMPEX 2017

• # Channels as Controllers (An Exercise in Refactoring)
  38:45 •  172 • Travis Vander Hoop
• # Everything Beautiful is in Plug
  12:10 •  247 • Omid Bachari
• # Functional Data Structures
  19:05 •  178 • Juan Soto
• # How to Bake π (Closing Keynote)
  37:07 •  489 • Eugenia Cheng
• # Monitoring Production Elixir Applications
  35:51 •  305 • John Kelly
• # Seussical Halting, Indeterminate Faulting
  14:36 •  81 • Bobby Grayson
• # Solid Ground
  35:15 •  5468 • Saša Jurić
• # The Language is the Least of It (Opening Keynote)
  37:10 •  647 • Jessica Kerr
• # When Does Concurrency Pay Off?
  18:20 •  133 • William Carroll

EMPEX LA 2018

• # A Swarm of Processes - Simulating Ant Foraging Behavior with OTP
  22:57 •  547 • Will Ockelmann Wagner
• # Become a Hex Power User
  24:29 •  284 • Todd Resudek
• # Building Beautiful Systems with Phoenix Contexts and Domain-Driven Design
  36:20 •  1188 • Andrew Hao
• # Closing Keynote
  44:55 •  296 • Sarah Gray
• # Deployment
  32:51 •  319 • Desmond Bowe • Benjamin Brodie • Scott Taylor
• # Ecto.Schema without Ecto.Repo
  15:26 •  486 • Rosemary Ledesma
• # Elixir Adoption
  18:46 •  267 • Shanti Chellaram • Brandon Richey
• # Embracing an Error-Prone Reality
  39:24 •  1103 • Emma Cunningham
• # Inclusion Starts with Docs
  34:37 •  188 • Pete Gamache
• # Life is but a Stream
  21:38 •  447 • Geoffrey Lessel
• # Shipping a Replacement Architecture in Elixir
  46:41 •  1563 • Chris Bell

EMPEX NYC 2018

• # GenStage: Keeping large amounts of data up-to-date with Pipelines
  28:39 •  381 • Robert Beene
• # Higher Level Functions for the Win
  17:57 •  294 • Bill Peregoy
• # Keynote
  39:52 •  6141 • Dave Thomas
• # Lessons Learned Building a Medication Service at Teladoc and How Ecto Saved the Day
  29:42 •  269 • James Lavin
• # Love potion number 9
  43:15 •  675 • Brooklyn Zelenka
• # Neuroevolution in Elixir
  18:57 •  386 • Jeff Smith
• # Pattern Matching: The Gateway to Loving Elixir
  19:20 •  454 • Kate Travers
• # Phoenix Presence: The Right Way To Track User Involvement in Real-Time Features
  18:28 •  571 • Sophie DeBenedetto
• # Recurrences & Intervals
  22:13 •  337 • Wojtek Mach
• # The Best of Both Worlds: High Performance Recommendations with Elixir NIFs
  28:23 •  219 • Shanti Chellaram
• # `mix new beats` -- Recreating The "Amen Break" with Elixir
  37:20 •  663 • Mat Trudel

Erlang DC 2013

• # Erlang metaprogramming with Elixir
  57:50 •  1876 • Yurii Rashkovskii

Erlang Factory 2014

• # dcouch, an Alternative to Mnesia with Unique Features
  48:37 •  505 • Benoît Chesneau

Erlang Factory 2015

• # Hex Package Manager
  38:25 •  623 • Eric Meadows-Jönsson
• # MongooseIM + Phoenix
  49:24 •  1326 • Michał Ślaski • Sonny Scroggin
• # Panel Discussion
  58:55 •  1971 • Bruce Tate • Guido van Rossum • John Hughes • José Valim • Robert Virding
• # Testing for Concurrency Errors in Elixir Code with QuickCheck
  48:35 •  935 • Thomas Arts
• # Tests Can Be Beautiful
  49:24 •  770 • Bruce Tate
• # What Elixir is About
  58:12 •  9300 • José Valim

Erlang Factory Lite Berlin 2014

• # Elixir Tooling
  34:06 •  260 • Eric Meadows-Jönsson
• # Erlang,Evolution
  37:24 •  526 • Robert Virding
• # Erlang-Lua: How to write an Erlang C Node
  29:28 •  716 • Robby Raschke
• # How To Ship New Code Without Taking Your System Down
  32:47 •  412 • Martin Rehfeld
• # Implementing Automated Trading System (...)
  23:01 •  425 • Anton Prokofiev
• # Latest News from the OTP Team
  19:08 •  272 • Bruce Yinhe
• # Lightning Talks
  32:29 •  406 • Michał Kalbarczyk • Sergej Jurecko • Valery Meleshkin
• # Monitoring Complex Systems(...)
  34:40 •  744 • Brian Troutwine
• # Riak Core in Small Bites
  24:28 •  562 • Mariano Guerra
• # The Cool Kids love Erlang
  35:34 •  723 • Gustav Simonsson • Henning Diedrich

Erlang Factory Lite Berlin 2016

• # BEAM all the things
  47:32 •  529 • Dave Cottlehuber
• # Extending OTP with custom behaviours
  29:06 •  538 • Michał Muskała
• # Process Data Streams Efficiently in Elixir
  32:24 •  1004 • Iuri Fernandes Queiroz
• # Supercharge your local BEAM Community
  52:07 •  350 • Ole Michaelis • Lydia Grawunder
• # Wireless Small Embedded Erlang Applications
  43:33 •  525 • Grisp-Adam Lindberg

Erlang Factory Lite Kraków 2012

• # Elixir - A modern approach to programming for the Erlang VM
  27:47 •  259 • José Valim
• # Erlang based Software Update Platform for mobile devices
  32:15 •  79 • Roman Janusz • Tomasz Kowal
• # Oortle - linearly scalable pub-sub system
  38:05 •  40 • Gleb Peregud
• # Parallel ranking of 1v1 computer games
  26:58 •  44 • Jesper Louis Andersen
• # QuickCheck for EUnit 
(using unit tests differently)
  31:14 •  58 • Thomas Arts
• # Towards simplicity
  28:13 •  42 • Arkadiusz Niemiec

Erlang Factory Lite London 2012

• # Automated testing with Erlang ('these go to eleven')
  01:25 •  283 • Ward Becker
• # Automated testing with Erlang ('these go to eleven')
  27:34 •  726 • Ward Becker
• # Build an FTP server in 30 minutes with Ranch
  00:19 •  412 •
• # Build an FTP server in 30 minutes with Ranch
  25:40 •  1138 •
• # CyLec - An Architecture for Electricity Smart Metering
  26:22 •  590 •
• # Google APIs and Erlang
  36:45 •  518 •
• # High Availability Erlang from the Trenches
  00:51 •  409 •
• # High Availability Erlang from the Trenches
  27:51 •  364 •
• # Hitchhiker's guide to the Erlang VM
  42:35 •  2052 •
• # Introduction to Webmachine
  31:30 •  976 •
• # MeshUp and other Riak hacks
  01:00 •  317 •
• # Profiling Erlang programs using Percept2
  01:52 •  275 •
• # Profiling Erlang programs using Percept2
  30:28 •  360 • Huiqing Li
• # Taming the Rabbit: Writing RabbitMQ Plugins
  30:25 •  421 •
• # The Ideal Programmer - Why They Don't Exist and How to Manage Without Them?
  00:48 •  256 •
• # The Ideal Programmer - Why They Don't Exist and How to Manage Without Them?
  49:13 •  707 •

Erlang Factory Lite Mexico City 2015

• # Conociendo la Maquina virtual de Erlang la BEAM
  47:55 •  347 • Norberto Ortigoza
• # Estrategias de Supervisión de Procesos
  38:56 •  166 • Misael Pérez Chamorro
• # From Ruby to Elixir, Developing Web Applications
  50:57 •  549 • Mario Chavez
• # Keynote: What's Ahead for Elixir?
  65:56 •  529 • José Valim
• # Lo mejor de dos Mundos, Aplicaciones OTP con Elixir
  36:39 •  440 • Erick Camacho
• # Poorman's gen_server
  38:12 •  353 • Hernán Rivas Acosta
• # Realizando pruebas con Elixir/Erlang
  38:07 •  113 • Agustín Ramos
• # Using a Raspberry Pi to run your Phoenix App
  32:50 •  717 • Ricardo Echavarria

Erlang Factory Lite Moscow 2012

• # Code generation to fight with complexity
  28:02 •  227 • Max Lapshin
• # Erlang Use Cases
  20:06 •  1762 • Michał Ślaski
• # Erlang Use Cases
  20:06 •  222 • Michał Ślaski
• # Erlang-Based Sensor Network Management for Heterogenous Devices
  29:15 •  210 • Michał Nieć
• # Erlang/OTP applications (...)
  26:39 •  251 • Alex Gunin
• # Lightning Talk - Asynchronous PostgreSQL driver for Erlang
  13:05 •  337 • Anton Lebedevich
• # Random choice
  25:21 •  60 • Bob Ippolito
• # Scalable ejabberd
  26:14 •  536 • Konstantin Tcepliaev
• # Scalable ejabberd
  26:14 •  87 • Konstantin Tcepliaev
• # Why Linux distributions are so disconnected from the reality? Are they really?
  34:43 •  272 • Peter Lemenkov

Erlang Factory Lite Munich 2013

• # 1000 Actors, One Chaos Monkey and... Everything OK
  43:46 •  215 • Pavlo Baron
• # An introduction to Riak
  27:43 •  7524 •
• # Build custom protocols with Ranch and msgpack
  25:17 •  996 •
• # Conversational big data
  28:07 •  109 • Darach Ennis
• # Diving into Erlang is a one-way ticket
  35:04 •  1366 •
• # Erlang and RTEMS Embedded Erlang, two case studies
  52:13 •  531 • Peer Stritzinger
• # Indenting Erlang Code Automatically (in Vim)
  30:53 •  310 • Csaba Hoch
• # OTP, the Middleware for Concurrent Distributed Scalable Architectures
  37:33 •  3386 •
• # Real-time card payments in Erlang
  36:06 •  387 • Gustav Simonsson
• # Riak Pipe, Distributed Data Processing
  44:47 •  1091 •
• # Taking the printf out of printf Debugging
  35:13 •  253 • Mats Cronqvist

Erlang Factory Lite Vancouver 2012

• # Erlang metaprogramming with Elixir
  29:29 •  562 • Yurii Rashkovskii

Erlang Factory SF 2012

• # "Big Data" and the Future of DevOps
  29:21 •  405 • Ram C Singh
• # A Scalability Study of Erlang/OTP
  53:52 •  426 • Kostis Sagonas
• # A World Without Linux
  39:38 •  1204 • Jim Zemlin
• # Accelerated Erlang Development with e2
  40:49 •  400 • Garrett Smith
• # BUBBA - Benchmarking Using Browser-Based Animation
  42:36 •  143 • Jay Nelson
• # Bitdeli - Data Crunching on a Shoestring Budget
  51:48 •  145 • Ville Tuulos
• # Boston Globe's use of Erlang to building a next-generation newspaper site
  24:41 •  133 • Jeff Moriarty
• # Building Cloud Storage Services with Riak
  39:21 •  762 • Andy Gross
• # Building a community around Healthy Distributed Systems
  46:20 •  34 • Mark Phillips
• # Building data-parallel pipelines in Erlang
  47:35 •  979 • Pero Subasic
• # Certifying your car with Erlang
  41:12 •  308 • John Hughes
• # Couchbase Performance and Scalability
  46:57 •  794 • Dustin Sallings • Matt Ingenthron
• # Dancing with Big Data: Disco + Inferno
  49:00 •  193 • Mazdak Rezvani • Tim Spurway
• # Data in the Cloud with Refuge
  45:57 •  23 • Benoît Chesneau
• # Deploying Erlang applications in the Heroku cloud
  39:37 •  323 • Blake Gentry • Geoff Cant
• # ErLLVM
  52:08 •  238 • Kostis Sagonas
• # Erlang Application Metrics with Folsom
  30:33 •  805 • Joe Williams
• # Erlang End-To-End - Building and Managing Connected Devices
  50:22 •  218 • Ulf Wiger
• # Erlang Scales - Do You?
  51:37 •  181 • Erik Stenman
• # Erlang Solutions Erlang Writ Large
  36:24 •  219 • Adam Kocoloski
• # Erlang and the "100 Million Problem"
  48:36 •  154 • Roger J Smith
• # Erlang as a Cloud Citizen
  37:55 •  143 • Paolo Negri
• # Erlang metaprogramming made easy
  49:37 •  392 • Richard Carlsson
• # Erlang on OpenVMS and in the HP Cloud (...)
  42:02 •  800 • Brett Cameron
• # Erlang on Xen - a quest for lower instance startup latency
  39:13 •  2085 • Maxim Kharchenko
• # Fear Not, or a Brief Introduction to Parse Transformations
  19:54 •  82 • Yurii Rashkovskii
• # Handling a Polyglotten WAN
  22:29 •  25 • Karl Anderson
• # How Cloud Foundry, the first Open PaaS, can help you (...)
  49:31 •  119 • Paul Jones • Monica Wilkinson
• # How to migrate a web API to Erlang, change databases (...)
  44:23 •  636 • Seth Falcon
• # IPv6 programming for Erlang/OTP
  44:25 •  259 • Kenji Rikitake
• # Implementing languages on the Erlang VM
  57:06 •  1086 • Robert Virding
• # Just-in-time compiler for the Erlang VM
  39:50 •  426 • Lukas Larsson
• # Leverage the World Wide West with Farwest
  27:55 •  68 • Loïc Hoguin
• # Magicbeam (or Devops Rules Everything Around Me)
  26:11 •  54 • Jonathan Freedman
• # Migrating a C++ team to using Erlang to deliver a real-time bidding ad system
  30:36 •  342 • Ken Wilson
• # Polyglot Paralellism - A Case Study in Using Erlang at Rackspace
  39:49 •  127 • Phil Toland
• # Real Time Bidding - Where Erlang Blooms
  44:33 •  1651 • Fred Hebert
• # Rewriting GitHub Pages with Riak Core, Riak KV, and Webmachine
  28:50 •  741 • Jesse Newland
• # Saloon - A simple interface for node and application monitoring
  35:12 •  84 • Magnus Klaar
• # Scaling Web Applications in Erlang
  43:11 •  534 • Fernando Benavides
• # Scaling to Millions of Simultaneous Connections
  43:37 •  5998 • Rick Reed
• # Small is Beautiful
  31:29 •  647 • Mike Williams
• # Spring Fever for your networks
  36:00 •  67 • Andreas Schultz • Holger Winkelmann
• # Step by Step - Implementing Redis In Erlang
  47:28 •  554 • Chad DePue
• # Test-First Construction of Distributed Systems
  31:51 •  176 • Joseph Blomstedt
• # The "halfword" Virtual Machine
  40:03 •  108 • Patrik Nyblom
• # The Erlang/OTP Roadmap
  20:32 •  228 • Patrik Nyblom
• # Using Erlang's Location Transparency For Devops Work
  26:12 •  382 • Noah Gift • Michael Bakkemo
• # Virtualizing Parallel Patterns for CPU/GPU Architectures
  37:04 •  357 • Horacio González-Vélez
• # What can be done with Java but should better be done with Erlang
  27:42 •  326 • Pavlo Baron
• # Your business depends on your customers - keeping them in the loop
  34:12 •  33 • Mahesh Paolini-Subramanya
• # eTorrent, writing Peer-to-Peer clients in Erlang
  40:06 •  411 • Jesper Louis Andersen

Erlang Factory SF 2013

• # A Layered Architecture: Robustness and Efficiency
  45:09 •  1204 • Dennis Docter
• # All your Cores are Belong to us: Turbo-Charging for the Many-Core World
  50:32 •  1622 • Alexander Gounares
• # Amateur Radio Propagation Analysis with Erlang/OTP and Riak
  49:36 •  281 • Kenji Rikitake
• # Analyzing Erlang with Big Data Techniques
  49:21 •  356 • Ying Li
• # Beating the No-Win Scenario: Testing a Distributed System
  45:20 •  574 • Joseph DeVivo
• # Believe in Erlang in Games
  45:55 •  1673 • James Mayfield • Mario Izquierdo • Noah Gift
• # Beyond MapReduce
  40:03 •  334 • Prashanth Mundkur
• # Building Riak CS on Riak
  35:59 •  244 • Reid Draper
• # Building a Messaging and Service Protocol
  45:38 •  479 • Jeremy Ong
• # Chicago Boss: A Web Framework Built for Comfort (and Speed)
  45:59 •  7294 • Evan Miller
• # Code Janitor: Nobody's Dream, Everyone's Job
  46:45 •  337 • Fred Hebert
• # Distributed Producer and Consumer Framework with Guaranteed Message Delivery
  40:06 •  556 • Guanhua Ye
• # Erlang Engine Tuning: Part 1 - Know your Engine
  53:47 •  2236 • Erik Stenman
• # Erlang Roadmap from Ericsson
  20:13 •  353 • Kenneth Lundin
• # Erlang and OpenFlow: A Match Made in the Cloud!
  49:19 •  332 • Stuart Bailey
• # Erlang does Nuclear Physics - Controlling Medium Scale Nuclear Physics Experiments
  50:11 •  342 • Jared Kofron
• # Genomu: A Concurrency-Oriented Database
  42:08 •  897 • Yurii Rashkovskii
• # High Throughput Erlang
  44:27 •  467 • Geoff Cant
• # Hitchhiker's Tour of the BEAM
  51:00 •  1284 • Robert Virding
• # How OpenX Built a Scalable Global Digital Revenue Platform
  48:01 •  1032 • Anthony Molinaro
• # Introducing LeoFS - the Lion of Storage Systems
  33:32 •  559 • Yosuke Hara
• # Introduction to Elixir: a New Language on the VM
  47:20 •  5940 • José Valim
• # KVDB - A Database System for Configuration Data and Connected Devices
  49:53 •  378 • Ulf Wiger
• # Kazoo: An Erlang-Based Elegant, Distributed Cloud Architecture for Communications
  47:40 •  1403 • James Aimonetti
• # LDB: The BigData In-Memory Database built with Erlang, C and LISP
  50:31 •  560 • Dionisis Kakoliris
• # LDB: The BigData In-Memory Database built with Erlang, C and LISP
  50:35 •  463 • Dionisis Kakoliris
• # Lager: Logging with Confidence
  46:29 •  1228 • Andrew Thompson
• # Lilith - Solving the Distributed Video Operations Challenge @ ESPN
  43:28 •  133 • John Kemp
• # Location, Location, Location
  22:46 •  212 • Christian Gribneau
• # Locker: Consistent Distributed Locking
  37:42 •  884 • Knut Nesheim
• # MongooseIM - Messaging that Scales
  47:25 •  1523 • Michał Ślaski
• # Multimedia Galore: Sending JPGs and 3GPs and AMRs!
  73:56 •  753 • Rick Reed
• # Neuroevolution Through Erlang
  46:47 •  4072 • Gene Sher
• # Realtime Logging: Alerts, Hashtags and Live Log Feeds
  44:17 •  223 • Martin Hald • Marc Campbell
• # Refuge: Build a Decentralized Data Platform
  44:19 •  245 • Benoît Chesneau
• # S**t happens - Are you Prepared?
  42:09 •  206 • Mahesh Paolini-Subramanya
• # Scaling Up from 1000 to 10 Nodes
  62:06 •  434 • Anton Lavrik
• # Services Platform: Experiments in OTP-Compliant Dataflow Programming
  51:58 •  315 • Jay Nelson
• # Spilgames Storage Platform
  48:57 •  488 • Enrique Paz Perez
• # Tailflow - An Openflow Controller Framework
  46:01 •  364 • Torbjörn Törnkvist
• # Taking Back Embedded: The Erlang Embedded Framework
  35:53 •  1330 • Omer Kilic
• # The How and Why of Fitting Things Together
  46:40 •  10435 • Joe Armstrong
• # The New Cowboy
  49:03 •  830 • Loïc Hoguin
• # The Polyglot Rabbit and the Big Fluffy Cloud
  48:17 •  343 • Brett Cameron
• # The Pooler Story: How I Learned OTP by Writing a Connection Pool
  43:59 •  1235 • Seth Falcon
• # WebSockets, RabbitMQ & Erlang @ the Huffington Post
  46:15 •  5517 • Adam Denenberg
• # Where are we on the Map?
  46:18 •  172 • Kenneth Lundin
• # Writing Beautiful Code
  55:59 •  6213 • Garrett Smith

Erlang Factory SF 2014

• # 10 Billion a Day, 100 Milliseconds Per: Monitoring Real Time Bidding at AdRoll
  48:25 •  3130 • Brian Troutwine
• # A Backpack to Go the Extra-Functional Mile
  52:20 •  283 • Laura M. Castro
• # An Open Erlang PaaS Done Right
  31:26 •  327 • Vladimir Kirillov
• # Bitcoin & Elixir: Living the Cutting Edge
  48:25 •  1261 • Yurii Rashkovskii
• # Building an IP Network Camera
  46:25 •  993 • Frank Hunleth
• # Caching Strategies for an Erlang Based Web Stack
  35:41 •  511 • Enrique Paz Perez
• # Caching Strategies for an Erlang Based Web Stack
  35:41 •  511 • Enrique Paz Perez
• # Catch me if you Can Processing Terabytes in Secs
  41:42 •  1806 • Jon Vlachogiannis
• # Comparison and Commentary on "Application Operating System"
  40:07 •  582 • C. Thomas Stover
• # Connecting the Internet of Things
  49:29 •  954 • Bryan Hughes
• # D3 + Websocket for Live Web Applications
  46:27 •  778 • Loïc Hoguin
• # Distributed Robots with Elixir
  27:00 •  1122 • Robby Clements • Josh Adams
• # Eliminating Single Process Bottlenecks with ETS Concurrency Patterns
  46:09 •  1641 • Jay Nelson
• # Erjang With the JVM under the Hood
  48:53 •  695 • Kresten Krab Thorup
• # Erlang + CZMQ: Scalable, Secure, Cross Language Messaging
  53:57 •  878 • Garrett Smith
• # Erlang IDE done right
  37:56 •  1400 • Sergey Savenko • Sergey Ignatov
• # Finding the Needle in the Haystack or Troubleshooting Distributed Systems
  41:29 •  301 • Anthony Molinaro
• # Intro to Haskell for Erlangers
  53:23 •  1238 • Bob Ippolito
• # Keynote Catalyse Change
  47:39 •  3137 • Dave Thomas • José Valim
• # LFE from 0 to 120kph... in 45 Minutes
  42:14 •  891 • Duncan McGreggor
• # Live Distributed Spying
  46:17 •  825 • Brian Mitchell
• # Lucene Server: From Erlang to Java and Back Again
  35:31 •  606 • Fernando Benavides
• # Memory Management: Battle Stories
  41:31 •  533 • Lukas Larsson
• # N2O - The Most Powerful Web Framework
  42:49 •  3032 • Maxim Sokhatsky
• # On the Scalability of the Erlang Virtual Machine and its Term Storage
  52:19 •  765 • Kostis Sagonas
• # Performance Optimization 101
  35:37 •  1590 • Louis-Philippe Gauthier
• # Performance Optimization 101
  35:37 •  1590 • Louis-Philippe Gauthier
• # Pipe Dreams - Getting More out of Elixir Pipes
  51:20 •  1069 • Bruce Tate
• # Planning for Overload
  43:58 •  1068 • Fred Hebert
• # Planning for Overload
  43:58 •  1068 • Fred Hebert
• # Profiling Applications using DTrace
  41:47 •  326 • Mark Allen
• # Real Time Performance at Massive Scale
  40:28 •  1678 • Francois Orsini
• # RefactorErl supports your Daily Work!
  52:29 •  357 • Melinda Toth
• # Riak Ensemble A Paxos based Framework for Scalable, Consistent Systems
  46:45 •  1680 • Joseph Blomstedt
• # Scalable Distributed Erlang
  48:31 •  833 • Natalia Chechina
• # Scaling ACID SQL VoltDB
  42:06 •  830 • Henning Diedrich
• # Scaling HTTP Connections
  39:27 •  465 • Benoît Chesneau
• # Sneaking Erlang in Through the Back Door
  43:47 •  654 • Bernard Duggan
• # Software Defined Networking
  49:51 •  591 • Stuart Bailey
• # Star Trek: revisited in Lua and Erlang
  50:08 •  497 • Kenji Rikitake
• # Step By Step Guide to Building an Application Analytics System
  41:05 •  2221 • Anton Lavrik
• # SumoDB a Clean Persistence Layer for Erlang OTP
  18:47 •  553 • Marcos Almonacid
• # That's 'Billion' with a 'B': Scaling to the Next Level at WhatsApp
  49:15 •  32991 • Rick Reed
• # The State of LFE: A Lisp Flavoured Smörgåsbord
  32:58 •  574 • Duncan McGreggor
• # The State of LFE: A Lisp Flavoured Smörgåsbord
  32:58 •  574 • Duncan McGreggor
• # Thursday Keynote -- What Programming is Really About
  43:16 •  3275 • Mike Williams
• # VM Tuning, Know Your Engine - Part III: The Scheduler
  47:32 •  476 • Erik Stenman
• # Verified Vector Clocks An Unexpected Journey
  46:24 •  763 • Christopher Meiklejohn
• # Write Less, Do More (and Have Fun!) with Elixir Macros
  52:01 •  2325 • Chris McCord
• # mod kazoo Crossing Language Barriers for Fun and Profit
  40:05 •  635 • Karl Anderson

Erlang Factory SF 2015

• # Actively measuring and profiling Code
  38:28 •  529 • Scott Lystig Fritchie
• # Actors for CyberThings
  56:05 •  3237 • Carl Hewitt
• # Building And Releasing A Massively Multiplayer Online Game
  55:26 •  12165 • Jamie Winsor
• # Building on top of riak core
  49:37 •  3172 • Mark Allen
• # DIY Using Erlang at a SF Startup From Day 1
  45:21 •  470 • Brian Wilhite • Noah Gift
• # Data Structure Adventures
  50:36 •  908 • Joseph Blomstedt
• # Debugging Complex Systems
  45:16 •  698 • Louis-Philippe Gauthier
• # Distributed Eventually Consistent Computations
  49:37 •  1730 • Christopher Meiklejohn
• # Efficient Architecting and Implementation of Systems
  38:30 •  417 • Martin Kristiansen
• # Embedded Erlang, Nerves, and SumoBots
  48:14 •  1152 • Frank Hunleth
• # Erlang Factory SF 2015 - News from the OTP Team
  15:34 •  195 •
• # Erlang Factory SF 2015 - The Timeless Way of Building Erlang Apps
  52:03 •  2841 •
• # Erlang Factory SF 2015 Keynote - From WhatsApp to Outer Space
  59:16 •  2861 •
• # Erlang in the Cloud: The Talko Service Architecture
  47:02 •  376 • Ransom Richardson
• # Evolving Projects to Concurrency with Wrangler
  47:48 •  232 • Simon Thompson
• # Gadget: The Ultimate Code Checking Machine
  32:03 •  465 • Fernando Benavides
• # Hex Package Manager
  31:58 •  132 • Eric Meadows-Jönsson
• # How to pick a Pool in Erlang without Drowning
  50:01 •  889 • Anthony Molinaro
• # IDE Done Right
  38:25 •  1506 • Sergey Ignatov • Sergey Savenko
• # LDB 10x Performance Increase
  42:29 •  380 • Daniel Pezely
• # Maximizing throughput on Multicore Systems
  42:44 •  476 • Irina Guberman
• # MongooseIM + Phoenix
  49:24 •  1326 • Michał Ślaski • Sonny Scroggin
• # Porting Erlang OTP to Exotic Platforms
  50:08 •  364 • Brett Cameron
• # Push Jobs: A Scalable Remote Execution System for Chef
  43:25 •  430 • Mark Anderson
• # QuickCheck-CI
  43:25 •  619 • John Hughes
• # Rebar 3
  51:10 •  904 • Tristan Sloughter • Fred Hebert
• # Scale, Manage and Prevent!
  46:19 •  535 • Viktória Fördős
• # Snippets
  01:30 •  143 •
• # Steganography and Data Hiding
  47:16 •  211 • Derek Brown
• # Teaching is Learning: Training New Hires
  42:37 •  469 • Inaki Garay
• # Testing for Concurrency Errors in Elixir Code with QuickCheck
  48:35 •  935 • Thomas Arts
• # Tests Can Be Beautiful
  49:24 •  770 • Bruce Tate
• # The Art of powering the Internet's Next Messaging System
  54:49 •  1070 • Simon Thompson
• # The Times They Are A-Changing
  41:16 •  787 • Lukas Larsson
• # What Docker Users Can Learn From Earlang
  46:19 •  994 • Dmitry Demeshchuk
• # What Elixir is about
  58:12 •  9300 • José Valim
• # What it is that make languages great?
  58:55 •  1971 • José Valim • John Hughes • Bruce Tate • Guido van Rossum • Mike Williams
• # Why Simplicity Matters: A Hardware Perspective
  50:29 •  3214 • Adreas Olofsson
• # Xorshift* and Erlang/OTP
  49:33 •  491 • Kenji Rikitake
• # gen_java: An easy way to include java in erlang applications
  44:03 •  444 • Joe DeVivo

Erlang Factory SF 2016

• # A CutEr Tool
  55:20 •  1452 • Kostis Sagonas
• # An Erlang based Philosophy for Service Reliability
  45:06 •  1836 • Jamshid Mahdavi
• # Build Scientific Computing Infrastructure with Rebar3 and Docker
  45:21 •  1484 • Eric Sage
• # Build a P2P Document Oriented Database
  38:46 •  414 • Benoît Chesneau
• # Build big with tiny tools immutability, checksums, and CRDTs
  48:17 •  766 • Scott Lystig Fritchie
• # Building high performance Erlang clients using Shackle
  41:10 •  573 • Louis-Philippe Gauthier
• # Composing Nodes
  43:58 •  370 • Marc Sugiyama
• # Concurrency + Distribution = Scalability + Availability, a Journey Architecting Erlang Systems
  52:15 •  1302 • Francesco Cesarini
• # Designing With Passion
  40:35 •  839 • Joe Armstrong • Evan Czaplicki • Bruce Tate • Dave Thomas • John Hughes
• # Effective Parallelization of Monte Carlo Calculations
  46:24 •  477 • Brett Cameron
• # Erlang On NixOS. Managing And Releasing Erlang Systems In The Cloud With A Fully Declarative Package Manager
  39:44 •  1391 • Eric Merritt
• # Erlang, Open Source and the Connected Car
  44:10 •  329 • Ulf Wiger
• # Fault Tolerant Sensor Nodes With Erlang OTP And Arduino
  53:17 •  633 • Kenji Rikitake
• # From Rebar2 to Rebar3
  34:04 •  772 • Tristan Sloughter
• # From Zero To Production
  50:34 •  1537 • Susan Potter
• # Here Be Dragons Charting Parse Transforms In Erlang
  53:46 •  681 • Garrett Smith
• # High Performance Erlang: Pitfalls and Solutions
  47:07 •  1062 • Yinghai Lu • Siva Yerramreddy
• # It's An Evolution! It's An Evolution!
  38:15 •  626 • Johnny Winn
• # Kafkerl: A Fault Tolerant Logging Library For Kafka
  35:33 •  560 • Hernán Rivas Acosta
• # Phoenix and Elm – Making the Web Functional
  55:29 •  21946 • Chris McCord • Evan Czaplicki
• # Point Of No Local Return. The Continuing Story Of Erlang Type Systems
  53:55 •  1031 • Zeeshan Lakhani
• # Reactive Programming With Elixir And RethinkDB
  36:29 •  2689 • Peter Hamilton
• # Roadmap
  29:54 •  1807 • Kenneth Lundin
• # Scaling RPC Calls In Erlang And Elixir
  47:09 •  1155 • Panagiotis Papadomitsos
• # Taking Off with Phoenix
  49:53 •  2296 • Sonny Scroggin
• # Testing Asynchronous APIs With QuickCheck
  39:29 •  1507 • Thomas Arts
• # The Climb: Experiencing the Rise of Elixir from the Inside
  43:23 •  6996 • Bruce Tate • Dave Thomas
• # The Future Of Tracing
  41:11 •  517 • Lukas Larsson
• # The Internet of Things as a Central Nervous System for Homes, Communities and Cities
  44:58 •  571 • Chad Curry
• # Well Typed Elixir
  44:41 •  1772 • Chris Keathley
• # What If Your NIF Goes Adrift
  42:49 •  480 • Julian Squires
• # What We Talk About When We Talk About Distributed Systems
  47:47 •  495 • Alvaro Videla
• # When ETS Is Too Slow
  36:04 •  1099 • Mark Allen
• # Why Functional Programming Matters
  60:57 •  14308 • John Hughes

Erlang User Conference 2012

• # (first '(Clojure.))
  48:48 •  441 • Niklas Lindström
• # A Few Improvements to Erlang
  43:31 •  3866 • Joe Armstrong
• # Alternatives in Error Handling
  25:53 •  155 • Dmitry Groshev
• # An Erlang-Based Framework for the Automatic Testing of Web Services
  43:25 •  622 •
• # Applied Rebar
  34:52 •  1529 •
• # Combinatorrent - a Haskell Case Study
  38:54 •  451 • Jesper Louis Andersen
• # Complex Event Processing on Arbitrary Data in Real-Time
  30:19 •  1809 •
• # Device Management in a Connected Society
  43:55 •  105 • Tony Rogvall
• # ErLLVM
  35:55 •  261 • Kostis Sagonas
• # Erlang Embedded - Concurrent Blinkenlights and More!
  22:50 •  154 • Omer Kilic
• # Erlang Embedded - Episode 4,Erlang to the Rescue!
  05:34 •  1096 •
• # Erlang The Movie II - Back to the Future of Web Telephony
  25:55 •  894 •
• # Erlang in the Browser
  34:26 •  625 •
• # Erlang metaprogramming made easy
  44:53 •  469 • Richard Carlsson
• # Innovation - What Every Developer Absolutely Needs to Know
  50:16 •  501 • Steve Vinoski
• # Just-in-time in No Time? Use the Source!
  34:08 •  249 • Frej Drejhammar
• # Latest News from the Erlang OTP Group
  27:32 •  118 • Kenneth Lundin
• # Mnesia Backend Plugin Framework and a LevelDB-based Plugin
  12:17 •  355 • Roland Karlsson • Malcolm Matalka
• # Reverse-Engineering a Proprietary Game Server with Erlang
  43:22 •  6616 •
• # Ruby & Erlang - at Scale with Style
  45:21 •  498 • Martin Rehfeld
• # Ruby & Erlang,at Scale with Style
  45:31 •  270 •
• # Starting a Software Company - Tips from the Trenches
  60:57 •  5692 • Jane Walerud
• # Sweden's Next Top NoSQL Data Model
  28:40 •  361 • Ian Plosker
• # Testing Eventual Consistency in Riak
  35:07 •  978 •
• # The Ericsson SGSN/MME, over a Decade of Erlang Success
  47:25 •  7605 • Urban Boquist
• # The Ideal Programmer - Why They Don't Exist and How to Manage Without Them?
  50:09 •  425 • Mike Williams
• # The Openflow Soft Switch
  22:04 •  534 • Krzysztof Rutka
• # Using Software Refactoring to Form Parallel Programs(...)
  34:23 •  234 • Chris Brown • Kevin Hammond

Erlang User Conference 2013

• # Meta-Programming with Elixir
  39:50 •  1961 • Yurii Rashkovskii

Erlang User Conference 2014

• # Large Partially-connected Erlang Clusters
  44:36 •  394 • Motiejus Jakštys

GOTO 2014

• # Elixir: The Power of Erlang, the Joy of Ruby
  49:42 •  17199 • Dave Thomas
• # Idioms for Building Distributed Fault-Tolerant Applications with Elixir
  52:59 •  9648 • José Valim

kievfprog 2013

• # Introducing Elixir
  41:12 •  49 • Alexei Sholik

Linux.conf.au 2014

• # Programming Elixir: The magic of today's tonic
  42:02 •  5502 • Katie Miller

London Erlang User Group 2014

• # Macros, and protocols and metaprogramming! Oh My!
  45:21 •  1070 • Jim McCoy

Lone Star Ruby Conference 2013

• # Elixir: Power of Erlang, Joy of Ruby
  39:04 •  8709 • Dave Thomas

Lonestar ElixirConf 2017

• # Closing Keynote
  64:04 •  4414 • Dave Thomas
• # Creating a Nerves-based Status Monitor
  32:50 •  1857 • Andrew Selder
• # Elixir Adoption at Scale: A Comprehensive Guide
  37:50 •  2650 • Ben Marx
• # Holistically built and tested APIs
  46:53 •  1667 • Brian Cardarella
• # How we Build Vutuv
  29:45 •  1706 • Stefan Wintermeyer
• # Leveling up your Phoenix Projects with OTP
  35:27 •  5278 • Nico Mihalich
• # Opening Keynote
  55:46 •  2781 • Justin Schneck
• # Phoenix 1.3
  51:44 •  33987 • Chris McCord
• # Raspberry Pi Cluster with the Power of Elixir
  17:38 •  1988 • Ricardo Echavarria
• # Shattering your application into an umbrella project
  31:58 •  3157 • Luke Imhoff
• # The NeverEnding Application
  43:46 •  1304 • James Edward Gray II • Paul Dawson
• # Using Ecto outside of Phoenix
  44:29 •  1878 • Geoffrey Lessel
• # Using Elixirscript
  34:45 •  1496 • Bryan Joseph

Lonestar ElixirConf 2018

• # Building on Sand: Firm Foundations from Legacy Databases
  26:36 •  335 • Ben Cates
• # Consistent Distributed Elixir
  42:01 •  109 • Chris Keathley
• # Customize your car: An Adventure in...
  55:34 •  387 • Brien Wankel
• # Day 1 Keynote
  56:27 •  263 • Chris McCord
• # Elixir is for Startups
  42:07 •  690 • Angel Jose
• # Intermediate SQL with Ecto
  32:48 •  608 • Dennis Beatty
• # Keynote
  47:26 •  1271 • Aaron Patterson
• # Keynote
  43:41 •  334 • Tim Mecklem
• # Let's Talk Process Dictionary
  44:41 •  336 • Greg Vaughn
• # Managing state in distributed Elixir
  33:14 •  994 • Jerel Unruh
• # The Next Phase of Elixir Deployment Tools
  41:59 •  964 • Paul Schoenfelder
• # Usercentered API Versioning
  40:29 •  627 • Niall Burkley
• # Why Elixir Matters A Genealogy of Functional Programming
  48:02 •  98 • Osa Gaius

NDC OSLO 2015

Oredev 2012

RailsConf 2014

• # All Aboard The Elixir Express! Workshop
  99:09 •  20278 • Chris McCord

RedDotRubyConf 2014

• # Ruby + Elixir: Polyglottin' FTW!
  28:07 •  1726 • Benjamin Tan Wei Hao

Ruby Conf 2013

• # The Polyglot in the Code - An Elixir/Ruby Mashup
  32:12 •  1027 • Johnny Winn

RuPy 2012

• # Elixir - A modern approach to programming for the Erlang VM
  32:43 •  3367 • José Valim

Singapore Ruby Brigade Meetup 2013

Solution Street hangout

• # Intro to Elixir
  41:13 •  37840 • Pete Broderick

The Big Elixir 2018

• # Cadre: Building Reliable Distributed Stateful Applications
  50:15 •  212 • Paul Schoenfelder
• # Exceptional: Staying on the Happy Path
  43:07 •  90 • Brooklyn Zelenka
• # Going Multi-Node
  34:49 •  97 • Eric Oestrich
• # Hot Upgrade Are Not Scary
  40:44 •  92 • Desmond Bowe
• # Leveraging GenStage to Implement Your Own Event Bus
  24:48 •  115 • Eli Kim
• # On Building Systems
  46:40 •  244 • Josh Adams
• # Physical Elixir
  51:31 •  63 • Justin Schneck
• # TIL By Breaking Production...
  31:06 •  86 • Jon Carstens
• # Testing a Large GraphQL API With Aplomb
  48:38 •  111 • Jeff Martin
• # Trapped By Our Tools
  45:19 •  129 • Ben Wilson
• # Using OTP / Presence for Real-time Analytics
  32:41 •  147 • Jacqui Manzi • Matt McClure