Elixir Talk

Follow Elixir Talk
Share on
Copy link to clipboard

Desmond Bowe and Chris Bell present a titillating discussion about Elixir application design and the state of the ecosystem. Ask us a question at https://github.com/elixirtalk/elixirtalk and follow us on Twitter @elixirtalk

Elixir Talk


    • Dec 4, 2020 LATEST EPISODE
    • infrequent NEW EPISODES
    • 44m AVG DURATION
    • 65 EPISODES


    Search for episodes from Elixir Talk with a specific topic:

    Latest episodes from Elixir Talk

    Episode 166 feat. Sean Stavropoulos

    Play Episode Listen Later Dec 4, 2020 52:22


    # Episode 166 - Elixir at Boulevard w/ Sean Stavropoulos We're back after a hiatus on our irregularly posted podcast! Chris and Desmond are back in the hot seat, this time joined by CTO and co-founder at Boulevard, Sean Stavropoulos where we hear all about the founding of Boulevard and their early adoption of Elixir and GraphQL. In this show, we touch on: * The adoption of Elixir early in 2017 * The adoption of GraphQL early * GraphQL vs REST, especially for third party APIs * Hiring Elixir engineers * How they deploy and run Elixir * How they do observability and monitoring * How stateful are their services * The future vision for Elixir at Boulevard ## Links - Boulevard: https://joinblvd.com - Sean on Twitter: https://twitter.com/seanstavro - Seven Languages in Seven Weeks: https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X - Absinthe GQL: https://github.com/absinthe-graphql/absinthe - Absinthe Dataloader: https://github.com/absinthe-graphql/dataloader - Apollo GraphQL: https://www.apollographql.com/ - Honeycomb: https://honeycomb.io - AWS Fargate: https://aws.amazon.com/fargate/ - Postgres tuning and performance at Pleroma: https://blog.soykaf.com/post/postgresql-elixir-troubles/ - Spandex: https://github.com/spandex-project/spandex - OpenCensus Elixir: https://github.com/opencensus-beam/opencensus_elixir - Absinthe Subscriptions: https://hexdocs.pm/absinthe/subscriptions.html

    Episode 165 feat. José Valim

    Play Episode Listen Later May 26, 2020 61:29


    # Episode 165 - José Valim on Bytepack, Open Source, and LiveView changes in Phoenix 1.5 Chris and Desmond are backed by a very special guest; José Valim! You might know José as the creator of the Elixir programming language and we're excited to have him back as a 3rd time guest on the show. José walks us through a brand new Dashbit project, Bytepack which is a way to package and sell software projects and takes all of the hassle out of the process today. We dig into Bytepack and discuss sustainable open source, Dashbit, and more. As well as that we also hear about the new Phoenix 1.5 features, LiveDashboard, all of the great new LiveView enhancements, some nice new Elixir additions and much more! A lot of links in this episode, think we got them all below but let us know if we missed anything

    Episode 164 - Quarantine Special: Module Organization in Elixir

    Play Episode Listen Later Apr 21, 2020 38:24


    We’re back with another episode of ElixirTalk. In this episode Chris & Desmond do a deep dive on organizing code in Elixir and talk about some best practices. We recorded this a couple weeks ago so it may sound a little stale :) We touch on: * Module and context naming * How we like to organize code in our projects * Big long modules vs many small modules * How to split up contexts * Injecting code via macros ## Links * On the Criteria to be used in decomposing systems into modules - D.L Parnas: https://www.win.tue.nl/~wstomv/edu/2ip30/references/criteria_for_modularization.pdf * Proposal for some ew rules for Phoenix contexts: https://devonestes.herokuapp.com/a-proposal-for-context-rules * Write code that is easy to delete, not easy to extend: https://programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to * How to use `use` well: https://dockyard.com/blog/2017/12/07/macro-madness-how-to-use-use-well * Protocols in Elixir: https://hexdocs.pm/elixir/Protocol.html

    Episode 163 - EMPEX LA Recap, Project Management Tools, and Monitoring

    Play Episode Listen Later Mar 6, 2020 41:25


    We’re back with a recap with another episode of ElixirTalk. In this episode we cover quite a few topics; an EMPEX LA recap, a foray into project management tools that we like and use (!), and then we round things out by talking about Chris integrating App Signal into his API at Muru. It’s a fun, jam packed episode with us going all around through many topics and go longer than we thought and off on an ops tangent (as usual). Times of topics: - Intro [00:00 - 03:40] - EMPEX LA Recap [03:40 - 17:10] - Project Management Tools: [17:10 - 25:40] - Monitoring / Metrics / Instrumentation: [25:40 - 39:30] - Close [39:30 - 41:00] ## Links * EMPEX LA: https://empex.co/la * Todd Resudek - It’s Time to Embrace Erlang: https://www.youtube.com/watch?v=mJb9wjUJhm4 * Shanti Chellaram - High Performance Data Structures in Erlang: https://www.youtube.com/watch?v=fdxhxAqxR94 * Jesse J. Anderson - Powering Pixels with Scenic: https://www.youtube.com/watch?v=w3L-VZtP_dY * Geoffrey Lessel - Controlling MIDI Devices in Real Time with Elixir – https://www.youtube.com/watch?v=4o4FzOFL2eE * Michael Reis - Nerves Takes to the Sky: https://www.youtube.com/watch?v=4o4FzOFL2eE * Jeff Grunewald - Stream-processing connected vehicle data in Elixir: https://www.youtube.com/watch?v=OKnY2hO2JdA * EMPEX NYC: https://empex.co/nyc * EMPEX NYC CFP: https://forms.gle/Vv3aqpXbtQA8a4TU8 * Desmond on Twitter: https://twitter.com/desmondmonster and Chris on Twitter: https://twitter.com/cjbell_ * Pivotal Tracker: https://www.pivotaltracker.com/ * Clubhouse: https://clubhouse.io/ * Linear: https://linear.app * Notion: https://notion.so * Appsignal: https://appsignal.com * Spandex: https://github.com/spandex-project/spandex * Datadog: https://datadog.com * Telemetry: https://github.com/beam-telemetry/telemetry

    Episode 162 feat. Bruce Tate

    Play Episode Listen Later Jan 31, 2020 57:14


    # Episode 162 - Designing Elixir Systems with Bruce Tate It's another episode of ElixirTalk, this time Chris and Desmond are joined by the one and only Bruce Tate author of many notable titles such as Programming Phoenix and Seven Languages in Seven Weeks, as well as being a frequent speaker on the circuit. We dig into the new Designing Elixir Systems with OTP book, that James Edward Gray, II and Bruce co-authored. We talk a lot about the way systems are put together, going into depth about the 'Do Fun Things with Big, Loud Worker-Bees' pattern that's advocated for in the book. Along the way we talk about software design, persistence and more. Come along for the ride, it's a fun one! ## Links - Bruce Tate on Twitter: twitter.com/redrapids - Grox.io: https://grox.io - Designing Elixir Systems with OTP: https://pragprog.com/book/jgotp/designing-elixir-systems-with-otp - Chris McCord Elixir Conf Keynote 2019: https://www.youtube.com/watch?v=txk4WAlabvI - The Climb at EMPEX 2016: https://www.youtube.com/watch?v=9lkO-kgxoiY - Seven Languages in Seven Weeks: https://pragprog.com/book/btlang/seven-languages-in-seven-weeks - Poncho Projects: https://embedded-elixir.com/post/2017-05-19-poncho-projects/ - Grox.io Quadblock Series: https://grox.io/series/quad - The River at Lone Star Elixir 2019: https://www.youtube.com/watch?v=KW85rW6-PgI - Justin Schneck goes to Very: https://www.verypossible.com/news/very-hires-justin-schneck-co-author-of-nerves-project?utm_content=111962264&utm_medium=social&utm_source=twitter&hss_channel=tw-1009603460 - EMPEX LA: https://empex.co/la - EMPEX NYC: https://empex.co/nyc - Lonestar Elixir Conference: https://lonestarelixir.com/ - Gig City Elixir Conference: https://www.gigcityelixir.com/ - Dev Next Conference: https://www.devdotnext.com/

    Episode 161 feat. Todd Resudek

    Play Episode Listen Later Jan 24, 2020 42:35


    # Episode 161 - feat. Todd Resudek We’re back with another episode of ElixirTalk, this time joined by the one and only Todd Resudek who gives us a run through of his talk at this years EMPEX LA entitled “It’s Time to Embrace Erlang”. Listen in to hear us discuss Todd’s nerve projects (including his recent LiveView Smart Mirror), why Todd thinks learning you some Erlang as an Elixir developer is important, and even about Hollywood Hogan and some other wrestling trivia. This show has it all. ## Links - EMPEX LA: https://empex.co/la - Intro to Elixir Training: https://ti.to/empex/empex-la-2020 - Todd on Twitter: https://twitter.com/sprsmpl - SimpleBet: https://www.simplebet.io/ - Building a “Smart Mirror” with Phoenix LiveView: https://medium.com/@toddresudek/building-a-smart-mirror-with-phoenix-liveview-18193ee6438f - Building a Smart Sprinkler Controller with Nerves - https://www.youtube.com/watch?v=qklciKp7sD8 - Erlang Crypto module: https://erlang.org/doc/man/crypto.html - Fred Hebert Advent of Code 2019 in Erlang: https://www.youtube.com/watch?v=TqzBchjZw4Q - Erlang Queue module: https://erlang.org/doc/man/queue.html - Erlang ETS module: https://erlang.org/doc/man/ets.html - Erlang Digraph module: https://erlang.org/doc/man/digraph.html - Learn you some Erlang: https://learnyousomeerlang.com/ - Adopting Erlang: https://adoptingerlang.org/ - Decompile Module: https://github.com/michalmuskala/decompile - Property-Based Testing with PropEr, Erlang and Elixir: https://propertesting.com/ - Lonestar Elixir Conference: https://lonestarelixir.com/ - CodeBEAM SF 2020: https://codesync.global/conferences/code-beam-sf/

    Episode 160-A new decade, Plataformatec acquisition, Elixir 1.10-rc and more

    Play Episode Listen Later Jan 8, 2020 45:18


    We’re back! It’s been a while but it’s 2020 and Chris and Desmond are back with a new episode for the new decade. In this very timely episode we dive into the big community news; Plataformatec being acquired and what that means for the community and the new Elixir v1.10-rc.0 release. After that, we accidentally stray once again into a spirited discussion about ops, Kubernetes, and picking technology that suits you right now. Desmond provides some controversial opinions and we kick off the new year with a bang :boom: ## Links in the show notes - EMPEX LA: https://empex.co/la - Bruce on Twitter: https://twitter.com/redrapids - James & Bruces book: https://pragprog.com/book/jgotp/designing-elixir-systems-with-otp - EMPEX NYC: https://empex.co/nyc - Plataformatec Announcement: http://blog.plataformatec.com.br/2020/01/important-information-about-our-elixir-and-ruby-open-source-projects/ - More context on the announcement on Elixir Forum: https://elixirforum.com/t/plataformatec-acqui-hired-by-nubank/28072/3 - Elixir v1.10.0-rc.0: https://github.com/elixir-lang/elixir/releases/tag/v1.10.0-rc.0 - Elixir 1.9 releases vs Distillery: https://elixirforum.com/t/elixir-1-9-release-vs-distillery/23454 - Jose on Elixir releases vs Distillery: https://news.ycombinator.com/item?id=20267585

    Episode 159 - Property-Based Testing & Authorization in APIs

    Play Episode Listen Later Dec 10, 2019 50:46


    Chris and Desmond are back! In this episode we talk about Desmond’s exploration into Property-Based testing, and then do a deep dive into authorization and access control in Chris’ GraphQL API. Property-based testing is a new world for both of us, but we do our best to tell you all about what libraries to use and how we’re thinking of using it. Chris is deep in some reworking of the authorization code in his GraphQL API and we go into depth talking about how it is structured, some of the challenges of building a flexible authorization system and then how this integrates back into a system. After talking about authorization we then go into validation of parameters in our APIs and how we think about typing and validating them at the boundaries, and in our Ecto Schemas. ## Links * EMPEX LA (https://empex.co/la) * StreamData Library for property testing (https://github.com/whatyouhide/stream_data) * PropEr (https://github.com/proper-testing/proper) * PropSchema (https://github.com/podium/prop_schema) * Property-Based Testing with PropEr (https://pragprog.com/book/fhproper/property-based-testing-with-proper-erlang-and-elixir) * StreamData: Property-based testing and data generation for Elixir (https://elixir-lang.org/blog/2017/10/31/stream-data-property-based-testing-and-data-generation-for-elixir/) * Canada Library (https://github.com/jarednorman/canada) * GraphQL Scalar Types in Absinthe (https://hexdocs.pm/absinthe/custom-scalars.html) * JSON Schema in Elixir (https://github.com/jonasschmidt/ex_json_schema) * API versioning at Stripe (https://stripe.com/blog/api-versioning)

    Episode 158 - Oban, Background Jobs, Concurrency, and Is Elixir Even Worth It?

    Play Episode Listen Later Nov 12, 2019 46:32


    # Episode 158 - Oban, Background Jobs and Designing Resilient Systems in Elixir. In this episode of ElixirTalk Chris & Desmond dive into background jobs using Oban, a new library that relies on Postgres to add persistence to job scheduling. We discuss why you’d want to reach for a library like Oban in the first place, which leads us to a discussion on distributed systems design, failure handling, and some of the gotchas of modeling everything in-memory. We’ve added some extra reading in the links belong for some articles that we didn’t mention in the episode, but might serve as good reading material regardless. ## Links - EMPEX LA: https://empex.co/la - Pigeon Push Notification: https://github.com/codedge-llc/pigeon - Oban: https://github.com/sorentwo/oban - Oban Recipes: https://sorentwo.com/2019/07/18/oban-recipes-part-1-unique-jobs.html - Eli Kim Leveraging GenStage to Implement You Own Event Bus: https://www.youtube.com/watch?v=ffhCUKI2_ho - Dangers of Single Global Process: https://keathley.io/blog/sgp.html - To spawn or not to spawn: https://www.theerlangelist.com/article/spawn_or_not

    Episode 157 feat. Chris McCord - LiveView/Phoenix part Deux

    Play Episode Listen Later Oct 24, 2019 58:08


    # Episode 157 – LiveView & The Future of Phoenix ft. Chris McCord Today on ElixirTalk we’re joined by Chris McCord who you may know as the creator of the Phoenix framework, and a second time guest on ElixirTalk. In this episode we talk quite a bit about LiveView, the journey of taking it from a prototype to release, the optimizations that have come along the way, and some of the great examples of LiveView running today. We get into some of our previous discussions about the balance of LiveView vs Javascript with Chris and how we frame the benefits of using the technology today. Additionally we hear about what’s on the roadmap for Phoenix, and the roadmap outside of the Phoenix core library itself. Thanks as always to Chris and the Phoenix Core team for their work! ## Links * ElixirConf 2018 – Announcing LiveView: https://www.youtube.com/watch?v=Z2DU0qLfPIY * ElixirConf 2019 – Chris’ Keynote: https://www.youtube.com/watch?v=txk4WAlabvI * What’s new and next for LiveView: https://dockyard.com/blog/2019/09/06/whats-new-and-next-for-phoenix-liveview * LiveView JavaScript Hooks: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#module-javascript-client-specific * LiveView in Marlus’ ElixirConf talk – https://www.youtube.com/watch?v=tPu-P97-cbE * Phoenix Presence and CRDTs: https://dockyard.com/blog/2016/03/25/what-makes-phoenix-presence-special-sneak-peek * Dark Lang: https://darklang.com * Oban Job Library: https://github.com/sorentwo/oban * Our discussion on LiveView: https://soundcloud.com/elixirtalk/episode-154-a-great-intro-elixirconf-recap-javascript-v-liveview * Phoenix Phrenzy Competition: https://phoenixphrenzy.com/ * Dockyard: http://dockyard.com

    Episode 156 - Desmond's new Job, Managing Complexity, and Designing Systems

    Play Episode Listen Later Oct 15, 2019 47:33


    # Episode 156 - Desmond & Chris face-to-face In todays special episode Desmond and Chris are together in NYC in-person for the first time in the history of recording Elixir talk. In the episode we dig into Desmond’s new role as CTO at Payitoff and talk about how Elixir helps in managing the complexity of student loans processing. We also discuss best practices in Elixir, some common gotchas in working in the language and more. ## Todays topics include: * Using tuples and tagged tuples * Structuring control flow for Elixir * Enforcing conventions in your codebase * Behaviours vs Protocols ## Links: * Payitoff: https://www.payitoff.io * Credo: https://github.com/rrrene/credo * Protocols in Elixir: https://elixirschool.com/en/lessons/advanced/protocols/ * Behaviours: https://elixirschool.com/en/lessons/advanced/behaviours/ * Plug Behavior: https://hexdocs.pm/plug/Plug.html#content * Mocks and Explicit contracts: http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/

    Episode 155 feat Brian Cardarella, Luke Imhoff, Paul Schoenfelder, and Hans Elias Josephsen - Lumen!

    Play Episode Listen Later Oct 9, 2019 69:23


    # Episode #155 - A special look into Lumen Today we have an extra special episode for you where we dig into a project you may have seen announced at the recent US Elixir Conference; Lumen, which is an alternate BEAM implementation, designed for WebAssembly. On the show we’re joined by the core members of the Lumen team: Brian Cardarella, Paul Schoenfelder, Luke Imhoff, and Hans Elias Bukholm Josephsen. We get into a lot of the details about the project; why it exists, what the goals are, what the hell web assembly is, and where it’s going. Join us and get a glimpse of a future direction for Elixir! ## Links * Lumen on GitHub: https://github.com/lumen/lumen * Keynote from ElixirConf: https://www.youtube.com/watch?v=uMgTIlgYB-U&feature=youtu.be * Hans talk from CodeBEAM on EIR: https://www.youtube.com/watch?v=xSWxlLCfF6s * EIR: https://github.com/eirproject/eir * web-sys crate in Rust: https://crates.io/crates/web-sys * wasm-bindgen crate in Rust: https://crates.io/crates/wasm-bindgen * Web Assembly Spec: https://github.com/WebAssembly/spec * Scenic: https://github.com/boydm/scenic * Issues for Lumen: https://github.com/lumen/lumen/issues * Lumen on Elixir Slack: #lumen

    Episode 154 - A Great Intro, ElixirConf Recap, Javascript v LiveView

    Play Episode Listen Later Sep 23, 2019 57:24


    ElixirTalk Episode 154 – ElixirConf recap and more! We’re back with another ElixirTalk episode after a short break! This time featuring Chris and Desmond reflecting on a great ElixirConf! We discuss our standout talks, as well as digging into the keynotes from Dockyard (Lumen), José Valim, Justin Schneck and Chris McCord. At the end of the episode we debate LiveView and it’s place in the broader JS ecosystem. Chris and Desmond somewhat disagree in this case. Let us know your thoughts, we’d love to hear more on this hotly debated subject. ## Links: * https://elixirtraining.io * https://elixirconf.com * Day 1 Morning Keynote - Brian Cardarella, Luke Imhoff, Paul Schoenfelder: https://www.youtube.com/watch?v=uMgTIlgYB-U * Day 2 Morning Keynote - Justin Schneck: https://www.youtube.com/watch?v=fRP_dVton7o * Elixir & CQRS - Jon Grieman: https://www.youtube.com/watch?v=-d2NPc8cEnw * BEAM Extreme Don’t Do This At Home - Miriam Pena: https://www.youtube.com/watch?v=-1j36z8SllI * Contracts for Building Reliable Systems - Chris Keathley: https://www.youtube.com/watch?v=tpo3JUyVIjQ * Norm library: https://github.com/keathley/norm * Thursday PM Keynote - José Valim: https://www.youtube.com/watch?v=tpo3JUyVIjQ * Return of Wabi-Sabi: Hastega Will Bring More and... - Susumu Yamazaki: https://www.youtube.com/watch?v=uCkPyfFhPxI * Friday Evening Keynote - Chris McCord: https://www.youtube.com/watch?v=txk4WAlabvI * EMPEX LA: https://empex.co/la

    Episode 153 feat. Dave Lucia- The Dream Stack with Rust & Elixir

    Play Episode Listen Later Aug 22, 2019 76:06


    Episode 153 – The Dream stack with Rust & Elixir feat. Dave Lucia We kick things off by hearing about the newly launched Elixir Training :tada: which y’all should check out if you’re looking to learn the language, or have friends who might. In todays episode we’re joined by Dave Lucia, VP of Engineering at SimpleBet where we hear about the use of the “Dream Stack” (you heard it here first folks!), which is Elixir using Rust NIFs for performance reasons (in their case calculating real-time betting odds). We spend a lot of time in the episode digging into what NIFs are, why Rust is a good fit for writing Elixir NIFs and what the pitfalls are. We get real technical with dirty schedulers, resource arcs in Rust, and all of the reasons for why you should and probably should not use NIFs unless you really need it. Also in an Elixir Talk first Dave turns around and asks us a question at the end. And in maybe a podcast first we place an on-air bet on who can donate the most to the Erlang Ecosystem Foundation. Links - Elixir Training North American Tour 2019 – https://elixirtraining.io - Elixir Conf – https://elixirconf.com - SimpleBet – https://simplebet.io - The Outline – https://theoutline.com - Two Years of Elixir at The Outline – https://blog.usejournal.com/two-years-of-elixir-at-the-outline-ad671a56c9ce - ConCache – https://github.com/sasa1977/con_cache - IO Lists and Phoenix - https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-in-phoenix/ - Using Rust to Scale Elixir at Discord – https://blog.discordapp.com/using-rust-to-scale-elixir-for-11-million-concurrent-users-c6f19fc029d3 - Rustler – https://github.com/rusterlium/rustler - Rust ResourceArcs in Rustler – https://docs.rs/rustler/0.15.1/rustler/resource/struct.ResourceArc.html - Erlang Dirty Scheduler Overhead – https://medium.com/@jlouis666/erlang-dirty-scheduler-overhead-6e1219dcc7 - Erlef – https://erlef.org - Dave’s talk at CodeBeam SF 2019 – https://www.youtube.com/watch?v=wvfhrvAFOoQ - Dave on Twitter – https://twitter.com/davydog187 - Dave on Github – https://github.com/davydog187

    Episode 152 - Hire an Elixir Developer! and Chris's Ecto Adventures

    Play Episode Listen Later Aug 14, 2019 46:54


    # Episode 152 - The joys of Ecto This week it’s a Chris & Desmond episode! We kick things off by hearing all about Desmond’s latest project – Hire an Elixir Developer – a job board to help companies attract Elixir talent that’s launching soon. We dig into how Desmond has been writing his latest project, hear a bit about how he’s using LiveView and how he’s chasing boring technology to get this project done (Phoenix & Elixir). Chris has also been writing lots of code this week (and has kept Elixirin’) – he talks a bit about how Elixir has mostly just been getting out of his way. We then dig into one of our favorite subjects ... Ecto! We describe the joy of named binds, how we split up Ecto queries, and think about composing queries. We then go onto talk about lateral joins and the limits of Ecto preloads. ## Links * Hire an Elixir Developer – https://www.hireanelixirdeveloper.com/ * Absinthe GraphQL – http://absinthe-graphql.org * Ecto Named Binds – https://hexdocs.pm/ecto/Ecto.Query.html#module-named-bindings * Ecto Preloads – https://hexdocs.pm/ecto/Ecto.Query.html?#preload/3 * Ecto update with an atomic increment – https://hexdocs.pm/ecto/Ecto.Query.html#update/3 * Ecto lateral joins – https://hexdocs.pm/ecto/Ecto.Query.html#join/5-joining-with-fragments * Dataloader – https://hexdocs.pm/dataloader/Dataloader.html * Lateral joins in Ecto – https://github.com/elixir-ecto/ecto/issues/1425 * Relay Connections – https://facebook.github.io/relay/graphql/connections.htm * Absinthe Relay – https://github.com/absinthe-graphql/absinthe_relay * Batch loading in Absinthe Relay while support first N – https://elixirforum.com/t/how-to-batch-load-with-absinthe-relay-while-supporting-first-x-and-after-cursor/14918 * CSS Grids – https://gridbyexample.com/examples/ * Brutalist Web Design – https://brutalist-web.design/ * ElixirConf – https://elixirconf.com/2019

    Episode 151 feat. Dave Thomas and Brian Mitchell - The Future of Elixir

    Play Episode Listen Later Aug 6, 2019 92:54


    # Episode 151 – Dave Thomas & Brian Mitchell In this special episode of ElixirTalk we are joined by Dave Thomas and Brian Mitchell where we continue a discussion that we had at EMPEX NYC this year as a fishbowl style format. If you haven’t yet seen the talk, you can do so here: https://youtu.be/pcbNT1iKebc –– probably best if you watch before listening, but you can also listen to this as a standalone episode. This episode is long, but is packed with some great tidbits about Elixir and Erlang and we go into considerable depth about how applications work today as well as outlining a vision for the future. ## Key moments in the episode - Dave lays out some of the key tenants of his argument about augmenting OTP to work better for a world that we’re in today - Brian describes what OTP is and gives his thoughts on Dave’s initial thesis, questioning some of the static nature that Dave argues about OTP - Dave lays out that what we’re doing in Elixir and Phoenix land is the OTP way (for better or for worse) and questions whether this is the best way to do things? - We talk at length about configuration and how things work today in Elixir / Erlang. Brian does a great job of explaining the different tenants of configuration in OTP that exist and we dig into what a dynamic model might look like. - We then talk about supervisors as they work in OTP and describe the concept of dynamic lifecycle management and a future vision of supervision that goes beyond just processes and extends into system observability. - We discuss challenging conceived wisdom and why that helps move communities forward, looking at the interesting case of how Elixir inherits decisions from the Erlang community and how we might revisit some of those assumptions. ## Links for this show - Dave and Brian’s discussion at EMPEX NYC: https://youtu.be/pcbNT1iKebc - Dave Thomas on Twitter: https://twitter.com/pragdave - Brian Mitchell on Twitter: https://twitter.com/strmpnk - Partisan: https://github.com/lasp-lang/partisan - Chris Meiklejohn’s talk on Partisan: https://www.youtube.com/watch?v=KrwhOkiifQ8 - ERLEF: https://erlef.org

    Episode 150 feat. Juan Facorro - Clojerl!

    Play Episode Listen Later Jul 18, 2019 45:47


    Episode 150 - Clojerl with Juan Facorro This week on the show we’re joined by Juan Facorro, an avid Erlang-er and creator of Clojerl, a Clojure port written in Erlang. We give you an update about Elixir Training, and tell you a bit more about a potential bar / meetup we at EMPEX will be hosting during ElixirConf this year in Denver (if we can find a bar). We then get Juan to give us a run through of Clojerl, diving into the project, his motivations for creating it and going in-depth to some of the challenges Juan had along the way. We understand why you’d even want Clojure on the BEAM in the first place and where the Erlang concurrency model is advantageous here. Links: - https://twitter.com/jfacorro - https://www.klarna.com/us/ - https://clojure.org/ - http://clojerl.online/ - Implementing Clojure on a new VM, clojureD: https://www.youtube.com/watch?v=NkHdMbI_08I - Clojure on the BEAM: https://www.youtube.com/watch?v=Ow8o9Mm_N7M - https://github.com/clojerl/ - https://erlang-slack.herokuapp.com/ - https://www.elixirtraining.io/blog/why-elixir-training

    Episode 149 - It's just Chris and Desmond. And Elixir Training!

    Play Episode Listen Later Jul 11, 2019 42:12


    This week we don’t have a guest, so it’s just Chris & Desmond. We kick things off discussing our opening music and how weird it is listening to yourself on a podcast. Desmond tells us about his exploration into webflow and his love (hate) for CSS. We dig into bits in the language that still trip us up, even now with our experience in the language. We dig into some Ecto: query syntax that trips us up, materialized views, application logic vs database logic and lots of other database goodies. Desmond tells us how Phoenix contexts trip him up and we go into some depth about how both of us structure contexts and code in our Phoenix applications. We tell you about ElixirTraining, which is our new venture to help teach more engineers the beauty of Elixir, as well as engineering leaders about why Elixir is a great fit for your organization. Oh, and sorry we said we’d answer some community questions and then never did. Links: - Webflow: https://webflow.io - Database tables explained: https://twitter.com/joygao/status/1141125981748383745?s=20 - Materialized views in Ecto: https://medium.com/@kaisersly/materialized-views-in-ecto-8887bc89efa5 - Ecto Postgres: https://github.com/bryanjos/geo_postgis - Rules for Phoenix contexts: http://devonestes.herokuapp.com/a-proposal-for-context-rules - Phoenix contexts in context: https://michal.muskala.eu/2017/05/16/putting-contexts-in-context.html - Andrew Hao’s talk on contexts: https://www.youtube.com/watch?v=l3VgbSgo71E - https://elixirtraining.io - https://elixirconf.com

    Episode 148 feat. Maxim Fedorov - Erlang at Scale in WhatsApp

    Play Episode Listen Later Jul 2, 2019 52:16


    Elixir Talk 148 - Feat Maxim Federov Desmond gives us an update on his truck and the work he’s been doing there. Chris tells us about how he’s been getting back into coding and how he’s been writing Absinthe and GraphQL. We announce a special new announcement: the launch of Elixir Training, our new business where we’re going out and looking to train more folks on Elixir across the US. We also have a special guest on the show this week: Maxim Federov a Software Engineer at WhatsApp. We dive into some of the joys of using Erlang at bonkers scale (~1.5 billion+ users), using 10k servers and attempt to ask some moderately interesting questions, that Maxim answers like a champ. Interesting links: - https://elixirtraining.io - Maxim’s talk about the architecture of WhatsApp: https://codesync.global/media/maxim-fedorov-scaling-erlang-cluster-to-10-000-nodes/ - https://www.infoq.com/presentations/whatsapp-scalability/ - https://erlef.org - https://www.facebook.com/careers/areas-of-work/whatsapp/?teams%5B0%5D=WhatsApp - https://codesync.global/media/mid-air-airplane-repair-troubleshooting-at-whatsapp/ - Live upgrade talk: https://codesync.global/media/the-art-live-upgrade-richard-carlsson/ - Hot upgrades in Elixir: https://medium.com/blackode/how-to-perform-hot-code-swapping-in-elixir-afc824860012 - Mnesia at WhatsApp: http://highscalability.com/blog/2014/3/31/how-whatsapp-grew-to-nearly-500-million-users-11000-cores-an.html - erlperf: https://github.com/max-au/erlperf

    Episode 147 - Elixir 1.9, Chris's new job, Desmond's new truck, and ElixirTalk Trainings!

    Play Episode Listen Later Jun 11, 2019 49:36


    *SHOW NOTES* - https://murumed.com - https://github.com/absinthe-graphql/absinthe - https://www.amazon.com/Craft-GraphQL-APIs-Elixir-Absinthe-ebook/dp/B07CSMHPKY/ - https://www.dropbox.com/s/6nn78jtf8ighry0/desmond-truck.jpg?dl=0 - https://crevalle.io - https://www.youtube.com/watch?v=JvBT4XBdoUE - https://www.instagram.com/thecolossusofroads/

    Episode 146 feat. Ben Marx - Adopting Elixir, Distributed Elixir, and more!

    Play Episode Listen Later Jun 6, 2019 55:05


    ** SHOW NOTES ** - https://twitter.com/bgmarx - https://bgmarx.com/ - https://www.amazon.com/Adopting-Elixir-Production-Ben-Marx/dp/1680502522 - https://dev.bleacherreport.com/diving-into-distributed-tracing-ce9638025576?gi=9f12645e5745 - https://elixirconf.com/2019/training-classes/1 - https://eventvivo.com/event/elixirconf-2019

    Episode 145 feat Fred Hebert - Erlang in Infrastructure, Property-Based Testing, and more!

    Play Episode Listen Later May 21, 2019 58:37


    * Fred Hebert: https://twitter.com/mononcqc * The Zen of Erlang: https://ferd.ca/the-zen-of-erlang.html * Erlang Ecosystem Foundation: https://erlef.org * Property-Based Testing Blog Post: https://ferd.ca/property-based-testing-with-proper-erlang-and-elixir.html * Property-Based Testing Book: https://pragprog.com/book/fhproper/property-based-testing-with-proper-erlang-and-elixir * Operable Software: https://ferd.ca/operable-software.html * EMPEX NYC: https://empex.co/nyc

    Episode 144 feat. Martin Sumner - Riak and Erlang at the NHS

    Play Episode Listen Later May 14, 2019 43:04


    ** SHOW NOTES** - Martin Sumner: https://twitter.com/masleeds - Riak: https://github.com/basho/riak - Spine: https://digital.nhs.uk/services/spine - Bet365 buys Basho assets: https://www.theregister.co.uk/2017/08/25/bet365_to_buy_basho_release_code/ - Martin's talk on Anti-Entropy: https://www.youtube.com/watch?v=TCiHqF_XTmE

    Episode 143 - Community Questions + GraphQL

    Play Episode Listen Later May 1, 2019 55:53


    **SHOW NOTES** * Joe Armstrong: https://twitter.com/FrancescoC/status/1119596234166218754 * Joe's Thesis: http://erlang.org/download/armstrong_thesis_2003.pdf * Erlang the Movie (OMG!): https://www.youtube.com/watch?v=uKfKtXYLG78 * Erlang the Musical (really?): https://www.youtube.com/watch?v=upiNIQOS4WE * EMPEX: https://empex.co/nyc * Contexts, pt 1: https://michal.muskala.eu/2017/05/16/putting-contexts-in-context.html * Our episode about app design: https://soundcloud.com/elixirtalk/episode-122-event-driven-architecture-microservices-and-evolving-application-architecture * Eli's Talk on Building Event Buses: https://www.youtube.com/watch?v=ffhCUKI2_ho * Off the Shelf Event Bus: https://github.com/otobus/event_bus * Example GenEvent: https://github.com/elixir-lang/gen_stage/blob/master/examples/gen_event.exs * Absinthe: https://github.com/absinthe-graphql/absinthe * Apollo: https://www.apollographql.com/docs/react/ * A deep dive into GraphQL: https://schneider.dev/blog/elixir-phoenix-absinthe-graphql-react-apollo-absurdly-deep-dive/

    Episode 142 feat. Sophie DeBenedetto - Elixir at the Flatiron School, Learning Functional Languages

    Play Episode Listen Later Apr 16, 2019 50:46


    **SHOW NOTES** - Sophie DeBenedetto: @sm_debenedetto - ElixirSchool: https://elixirschool.com/en/ - The Flatiron School: https://flatironschool.com/ - Great Code Adventure: http://thegreatcodeadventure.com/ - Troy's Cocktails Podcast: https://www.briefs.fm/cocktailing - Erlang Ecosystem Foundation: https://erlef.org/ - EMPEX NYC: https://empex.co/nyc

    Episode 141 - More LiveView Stuff and Desmond Wants to Work With You

    Play Episode Listen Later Apr 10, 2019 31:03


    ** SHOW NOTES ** * http://crevalle.io * https://empex.co/nyc * https://twitter.com/sasajuric/status/1111987993529729025 * https://twitter.com/moomerman/status/1111711999963086849 * https://twitter.com/_zorbash/status/1112859727845904385 * https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascript

    Episode 140 feat. Chris McCord - Phoenix LiveView!

    Play Episode Listen Later Mar 19, 2019 44:43


    ** SHOW NOTES ** - LiveView Repo: https://github.com/phoenixframework/phoenix_live_view - LiveView Examples: https://github.com/chrismccord/phoenix_live_view_example

    Episode 139 feat. Zach Smith - EMPEX LA, ErlEF, Macros, and Functors, oh my!

    Play Episode Listen Later Mar 5, 2019 50:12


    ** SHOW NOTES ** - Zach Smith (https://blog.zdsmith.com/index.html) - Erlang Ecosystem Foundation (https://erlef.org) - EMPEX YouTube Channel (https://youtube.com/empexconference) - Brooklyn Zelenka's EMPEX talk (https://www.youtube.com/watch?v=DZEs8_QiC8Q&list=PLyO-58-sOapw81dCfjDrX5TuYxS5S8qMq) - Witchcraft (https://github.com/expede/witchcraft) - Bryan Weber/Code Generation in Elixir (https://www.youtube.com/watch?v=-mgwW3RVI50&index=2&list=PLyO-58-sOapw984fSPNyzCyX7SADFn0w0) - EMPEX NYC (http://empex.co/nyc) - Zach's blog post (https://blog.zdsmith.com/posts/sketches-of-elixir.html) - Cameron Price discussing Leex and Yecc (https://cameronp.svbtle.com/how-to-use-leex-and-yecc)

    Episode 138 - EMPEX LA recap, Training Newbies, and Why You Shouldn't Store State in GenServers

    Play Episode Listen Later Feb 19, 2019 36:59


    ** SHOW NOTES ** * https://www.youtube.com/watch?v=b3JQgyj17hk&index=2&t=2s&list=PLyO-58-sOapyHWNFBapGOz40efbJuwmx2 * https://www.youtube.com/watch?v=5LlpbWuB9Hc&index=3&t=1s&list=PLyO-58-sOapyHWNFBapGOz40efbJuwmx2 * https://www.youtube.com/watch?v=9216dUNgKCU&index=11&t=4s&list=PLyO-58-sOapyHWNFBapGOz40efbJuwmx2 * http://empex.co/nyc.html * http://elixirschool.com

    Episode 137 feat. Devon Estes - Benchee, Assertions, and Opera, who knew?

    Play Episode Listen Later Feb 12, 2019 42:37


    ==SHOW NOTES== • https://empex.co/la • https://devonestes.com • https://github.com/PragTob/benchee • https://github.com/devonestes/assertions • https://testmetrics.app/

    Episode 136 - Our Github Flows, New Years Code Goals, and Realtime Thoughts

    Play Episode Listen Later Jan 31, 2019 29:13


    ** SHOW NOTES ** come to EMPEX LA! http://empex.co

    Episode 135 feat. Chris Hildebrand - Migrating an Elixir App Off Kubernetes

    Play Episode Listen Later Jan 15, 2019 41:35


    **SHOW NOTES** - you can find Chris online at https://chrishildebrand.net/ and under the handle @ckhrysze

    Episode 134 - Flow, Serving Static Sites with Phoenix, EMPEX LA!

    Play Episode Listen Later Jan 15, 2019 25:17


    **SHOW NOTES** cjbell [5:33 PM] * https://empex.co/la * https://hexdocs.pm/flow/Flow.html * https://nerves-project.org/ * https://hexdocs.pm/phoenix/Phoenix.Endpoint.html * https://soundcloud.com/elixirtalk/episode-122-event-driven-architecture-microservices-and-evolving-application-architecture

    Episode 133 - Keyword Lists vs Maps, Boolean Operators, the Match keyword

    Play Episode Listen Later Dec 11, 2018 33:18


    ** SHOW NOTES ** * https://adventofcode.com/ * https://www.youtube.com/watch?v=zZxBL-lV9uA * https://elixir-examples.github.io/examples/boolean-operators * https://hexdocs.pm/elixir/Kernel.html#match?/2

    Episode 132 - Hello! and Macros. Lots of macros.

    Play Episode Listen Later Nov 28, 2018 28:59


    **SHOW NOTES** • https://empex.co/la • https://elixirschool.com/en/lessons/advanced/metaprogramming/ • https://hackernoon.com/understanding-elixir-macros-3464e141434c • https://pragprog.com/book/cmelixir/metaprogramming-elixir also Desmond is on the Elixir slack as @desmond, not desmondmonster.

    Episode 131 - The Big Elixir preview and EMPEX LA

    Play Episode Listen Later Nov 6, 2018 25:27


    **SHOW NOTES** https://www.thebigelixir.com/ http://empex.co

    Episode 130 - Desmond's (lost) Mustache, Ecto3, Database Views & Windows

    Play Episode Listen Later Oct 23, 2018 28:59


    **SHOW NOTES** One year of ElixirTalk! Thanks everyone for listening! *http://blog.plataformatec.com.br/2018/10/a-sneak-peek-at-ecto-3-0-breaking-changes/ *https://www.youtube.com/watch?v=YQxopjai0CU *https://www.youtube.com/watch?v=QE7bpqpDoKo

    Episode 129 - Param Validation, Libcluster, and Elixir After 3 Years

    Play Episode Listen Later Oct 2, 2018 26:06


    ** SHOW NOTES ** * https://github.com/ElixirTalk/elixirtalk/issues/44 * https://github.com/akoutmos/pharams * https://github.com/vic/params * https://github.com/jonasschmidt/ex_json_schema * https://github.com/bitwalker/libcluster * https://www.youtube.com/watch?v=L2_MUD16EIk

    Episode 128 - Phoenix LiveView, the Next Five Years of Elixir

    Play Episode Listen Later Sep 25, 2018 30:19


    ** SHOW NOTES ** • https://elixirconf.com • https://www.youtube.com/watch?v=Z2DU0qLfPIY&feature=youtu.be • https://github.com/phoenixframework/phoenix/blob/master/CHANGELOG.md • https://kinsta.com/learn/what-is-http2/ • https://www.youtube.com/watch?v=suOzNeMJXl0 • https://www.youtube.com/watch?v=1QNxLNMq3Uw

    Episode 127 - Scaling Desmond's App, Kubernetes, Property-Based Testing, and more!

    Play Episode Listen Later Sep 11, 2018 42:39


    Episode 127 - Scaling Desmond's App, Kubernetes, Property-Based Testing, and more! by Elixir Talk

    Episode 126 - Distillery 2, ElixirConf, and Your Communities

    Play Episode Listen Later Sep 4, 2018 28:34


    ** show notes ** https://dockyard.com/blog/2018/08/23/announcing-distillery-2-0

    Episode 125 - Open Source Contributions, Phoenix Bugs, and GraphQL

    Play Episode Listen Later Aug 28, 2018 33:44


    ** Show Notes ** • https://www.opengoldbergvariations.org/ • https://github.com/Frameio/cereal_ex • https://www.apollographql.com/ • https://github.com/phoenixframework/phoenix • https://github.com/absinthe-graphql/absinthe • https://github.com/vt-elixir/ja_serializer • http://jsonapi.org/

    Episode 124 - Application monitoring, instrumentation, and error reporting.

    Play Episode Listen Later Aug 14, 2018 46:50


    We discuss application monitoring, instrumentation, and error reporting. ** SHOW NOTES ** • https://github.com/ferd/vmstats • https://timber.io • https://sentry.io/ • https://www.datadoghq.com/ • https://hackernoon.com/a-tour-of-elixir-performance-monitoring-tools-aac2df726e8c • https://github.com/lexmag/statix • https://github.com/ferd/recon • https://appsignal.com/elixir • https://scoutapp.com/elixir-monitoring • http://elastic.co/ • https://aws.amazon.com/elasticsearch-service/ • https://www.elastic.co/products/kibana • https://github.com/pinterest/elixometer • https://github.com/Feuerlabs/exometer • https://pulse.crevalle.io

    Episode 123 - Ecto!

    Play Episode Listen Later Aug 7, 2018 53:26


    Ecto, Ecto, and more Ecto! We discuss the different ways we use this versatile tool for much more than just database queries. ** SHOW NOTES ** • medium.com/frame-io-engineerin…-sagas-583d1cd2b149 • github.com/Nebo15/sage • github.com/elixir-ecto/ecto • blog.drewolson.org/composable-queries-ecto/ • www.youtube.com/watch?v=fFqsMWmONN4

    ecto nebo15
    Episode 122 - Event-Driven Architecture, Microservices, and evolving Application Architecture

    Play Episode Listen Later Jul 31, 2018 42:33


    How does Chris use an Event Bus in his app? Is it cool or is it lame? Also, how does your app grow, and what are the design rules you use to respond to that? ** SHOW NOTES ** no notes this time!

    Episode 121 - Editors & Workflow, Module Design, Imports & Aliases, and Function Typing

    Play Episode Listen Later Jul 24, 2018 50:53


    What editors do we use when writing Elixir? What's our testing workflow? We also discuss why and when we use imports and aliases in our modules, and the pros and cons of typing our function calls. And Desmond has a new job! ** show notes ** https://www.versussystems.com/ https://twitter.com/_asummers/status/1011716230598807552 https://github.com/JakeBecker/elixir-ls http://www.alchemist-elixir.org/ https://github.com/JakeBecker/vscode-elixir-ls https://github.com/elixir-editors/vim-elixir

    Episode 120 feat. Mat Trudel - Timers in the VM, SchedEx, and Factory Automation

    Play Episode Listen Later Jul 3, 2018 40:22


    We chat with EMPEX NYC 2018 speaker Mat Trudel to discuss his SchedEx library, timers in the Erlang VM, factory automation, and more! ** show notes ** https://github.com/mtrudel https://github.com/mtrudel/beats https://github.com/SchedEx/SchedEx https://www.youtube.com/watch?v=XN4WuOujr38 https://happi.github.io/theBeamBook/#_waiting_timeouts_and_the_timing_wheel

    Episode 119 - Using Plug to Chain Functions, Decorators, and Sage

    Play Episode Listen Later Jun 26, 2018 39:31


    A follow up to a previous episode about consolidating code, we discuss the option of using Plug to handle chained event logic. Plus the benefits of decorators and the Sage library for transactions. ** show notes ** - http://empex.co/la - https://gist.github.com/mmmries/424afa5b73ef597d56037b5b2591561e - https://medium.com/elixirlabs/railway-oriented-programming-in-elixir-with-pattern-matching-on-function-level-and-pipelining-e53972cede98 - https://twitter.com/tef_ebooks/status/1008358865279291392 - https://github.com/arjan/decorator - https://medium.com/nebo-15/introducing-sage-a-sagas-pattern-implementation-in-elixir-3ad499f236f6 - https://github.com/Nebo15/sage

    Episode 118 feat. Paul @bitwalker Schoenfelder - Deployment, Configuration, and more!

    Play Episode Listen Later Jun 19, 2018 47:43


    Our chat with the famous Paul Schoenfelder aka bitwalker, creator of Distillery, Swarm, and more! We discuss deployment strategies, the integration of Distillery into Mix, how the configuration discussion affects advances in deployment, and more. ** show notes ** - https://elixirforum.com/t/proposal-moving-towards-discoverable-config-files/14302 - http://erlang.org/doc/design_principles/appup_cookbook.html - https://github.com/bitwalker - https://dockyard.com

    Episode 117 feat. Andrew Summers - Dialyzer and its new Pretty Printer

    Play Episode Listen Later Jun 14, 2018 38:18


    We sit with Andrew Summers, contributor to the Dialyxir project and author of its new Pretty Printer. ** SHOW NOTES ** https://github.com/jeremyjh/dialyxir http://erlang.org/doc/man/yecc.html https://github.com/asummers

    Episode 116 - Injecting GenServer state, the Freedom Formatter, and Behaviours

    Play Episode Listen Later Jun 5, 2018 48:44


    We discuss injecting state into a new GenServer, Pete Gamache's Freedom Code Formatter, and a question about whether using a Behaviour is invoking the pains of OOP inheritance. ** SHOW NOTES ** https://github.com/gamache/freedom_formatter

    Claim Elixir Talk

    In order to claim this podcast we'll send an email to with a verification link. Simply click the link and you will be able to edit tags, request a refresh, and other features to take control of your podcast page!

    Claim Cancel