The ElixirTalk Podcast

Taking questions from around the Elixir community about application design principles and the state of the ecosystem. Ask us a question!

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

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

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

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

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

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

Episode 150 feat. Juan Facorro - Clojerl!

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:

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

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:

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

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:

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

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

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

SHOW NOTES

Episode 140 feat. Chris McCord - Phoenix LiveView!

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

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

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

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

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

SHOW NOTES

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

Episode 131 - The Big Elixir preview and EMPEX LA

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

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

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

Episode 126 - Distillery 2, ElixirConf, and Your Communities

Episode 123 - Ecto!

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

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

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

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

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 118 feat. Paul @bitwalker Schoenfelder - Deployment, Configuration, and more!

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

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

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

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

Episode 115 - Our EMPEX Recap and Open Source Initiatives!

Our EMPEX Recap! We discuss our favorite talks, an Open Source proposal, and Dave Thomas’ controversial opinions about higher-level abstractions in Elixir.

SHOW NOTES https://github.com/wojtekmach/calendar_recurrence / https://github.com/wojtekmach/calendar_interval https://github.com/pragdave/component

Episode 114 - Training up Teams on Elixir

What are strategies for onboarding a team in Elixir?

Episode 113 - Typespecs, Tests, Hot Code Upgrades, and EMPEX!

show notes Typespec correction: http://crevalle.io/maps-in-typespecs.html EMPEX: http://empex.co

Episode 112 - Caching and Process in Production, Elixir Segment Libraries, Ready Player One review!

Episode 110 - When to Use/Not Use GenServers or Umbrella Apps

Lots of developers coming to Elixir misuse GenServers and Umbrella applications, thinking that just because they have these tools, they should use them. But that’s not always so!

Have a listen for our perspective on when to reach for GenServers and when not to.

Episode 109 - Authorization/Authentication in Phoenix apps, Higher-Level App Patterns

Episode 108 - Multiple Elixir Versions, How Much Erlang Should You Know, & Thinking Functionally

EMPEX LA is this weekend! Get your ticket to meet ElixirTalk hosts Desmond and Chris!

http://empex.co/la

Episode 106 - Chat with José Valim

We hang out with José Valim, creator of Elixir, and discuss new features in Elixir 1.6, tips to build better applications, and (of course) Star Trek.

Episode 105 - Drop-in Libraries & Supervisors

Episode 104 - Storing State in Elixir Apps

How should you think about storing state in your Elixir apps? Should you use a traditional external datastore? Or one of the built-in constructs: GenServers, ETS, DETS, or mnesia?

Episode 103 - Umbrella Apps

When should you use Umbrella Apps?

Back to the home page