Elixir Wizards

SmartLogic LLC

Elixir Wizards is an interview-style podcast for anyone interested in functional programming and the Elixir Programming Language. Hosted by SmartLogic engineers and Elixirists Owen Bickford, Dan Ivovich, and Sundi Myint, this show features in-depth discussions with some of the brightest minds in the industry, discussing training and documentation in Phoenix LiveView, the evolution of programming languages, Erlang VM, and more. In the current season, we're branching out from Elixir to compare notes with thought leaders and software engineers from programming languages like JavaScript, Ruby on Rails, Go, Scala, Java, and more. Each episode will take a deep dive into a topic from Machine Learning and AI, to ECS and game development, to education and community. Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)

All episodes

Best episodes

Seasons

Top 10 Elixir Wizards Episodes

Goodpods has curated a list of the 10 best Elixir Wizards episodes, ranked by the number of listens and likes each episode have garnered from our listeners. If you are listening to Elixir Wizards for the first time, there's no better place to start than with one of these standout episodes. If you are a fan of the show, vote for your favorite Elixir Wizards episode by adding your comments to the episode page.

Steve Domin on Innovating Travel APIs

Elixir Wizards

01/08/21 • 38 min

Anyone who has written software for the travel industry can tell you that it is in desperate need of innovation — shockingly many of their cobwebbed systems were built in the 70s. Today we speak with Duffel CEO Steve Domin, who is building tech that can finally align travel with the expectations of modern consumers. We open by exploring Steve’s journey into coding before diving into how Duffel is innovating travel. After touching on how the pandemic has impacted Duffel’s roll-out, Steve shares horror stories about the outdated tech and API systems that airlines use. We discuss Duffel’s service offerings and why Elixir is uniquely suited to solve the problems that Steve’s company is addressing. Steve then talks about the types of engineers that Duffel hires, his client base, and where his company is heading. Near the end of the episode, we ask Steve for his advice on selling your company on Elixir and we chat about the status of the London Elixir Meetup. Tune in for more insights on how Steve is using Elixir to make travel an effortless experience.

Key Points From This Episode:

Introducing Duffel CEO Steve Domin.
Steve shares details about his coding journey and career highlights.
Insights into the old school ecosystem of Flash, Flex, and ActionScript.
Exploring how Duffel is innovating the travel industry.
Why Duffel accelerated their roll-out due to the pandemic.
Steve unpacks the outdated tech and API systems that airlines use.
Why Duffel decided to use Elixir to tackle their problems.
The benefits of using Elixir when dealing with airline data.
Steve gives listeners an overview of Duffel’s pipeline.
Insights into the types of engineers that Duffel hires.
Who Duffel’s clients are and how they’re onboarded.
Steve reflects on some airline API horror stories.
Hear about Duffel’s roadmap — the future is bright.
What Elixir has uniquely enabled Duffel to do.
Steve’s advice on selling Elixir to stakeholders in your company.
The status of the London Elixir Meetup.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Steve Domin — https://stevedomin.com/about
Steve Domin on LinkedIn — https://www.linkedin.com/in/stevedomin/
Steve Domin on Twitter — https://twitter.com/stevedomin
Duffel — https://duffel.com/
Duffel Careers — https://duffel.com/careers
José Valim — https://twitter.com/josevalim
Flex — https://www.adobe.com/products/flex.html
Passenger Service System — https://en.wikipedia.org/wiki/Passenger_service_system
Global Distribution System — https://en.wikipedia.org/wiki/Global_distribution_system
Sabre — https://www.sabre.com/
Amadeus — https://amadeus.com/en
‘Why does NDC matter to my travel business?’ — https://duffel.com/blog/why-does-ndc-matter-to-my-travel-business
IATA — https://www.iata.org/
Next.js — https://nextjs.org/
GoCardless — https://gocardless.com/
Twilio — https://www.twilio.com/
Stripe — https://stripe.com/
Thomas Bates — https://www.linkedin.com/in/thomas-bates-3908a74b/
Elixir London Meetup — https://www.meetup.com/Elixir-London/
Baris Balic — https://twitter.com/barisbalic

Special Guest: Steve Domin.

Dan Ivovich from SmartLogic - Elixir in Production

Elixir Wizards

02/28/19 • 28 min

We talk with developers from the team here at SmartLogic about our current practices on deploying Elixir and Phoenix in production.

Dan Ivovich - Director of Development Operations @ SmartLogic

Learn more about how SmartLogic uses Phoenix and Elixir.

00:00 - Fade In

00:30 - Introductions to Eric, Dan and SmartLogic

Dan Ivovich - Director of Development Operations @ SmartLogic

Eric Oestrich - Developer, Elixir Lead @ SmartLogic

Justus Eapen - Full stack developer @ SmartLogic

Introduced to Elixir by an old colleague.

1:20 - What Elixir projects do you have in production?

Several client projects in production. Several Mobile Apps with APIs powered by Phoenix and Elixir.

Baltimore Water Taxi.

A digital marketplace.

And more!

1:57 - Advantages and disadvantages to using Elixir.

We made the switch when a colleague was stoked about Functional Programming and introduced us to Elixir. We were won over by the performance and rich feature sets, OTP, etc.

2:43 - Where are we hosting our Elixir Apps?

Heroku
AWS
Linode
Digital Ocean

6:20Deployment process, tools, scripting

Ansible - for underlying VPS’s, servers, and more recently deployment itself. (Similar to Capistrano).
Distillery
Mix.release

7:18 - Zero Downtime Deployments

Old school load balancers and rolling restarts

7:46 - What are the performance metrics like? Comparatively.

Ruby ends up with memory leaks. That doesn’t happen with Elixir.
Memory utilization is flat and low no matter what.
“Phenomenal response times”

8:54 - How does Eric think about clustered applications in Elixir?

Going Multi Node (https://www.youtube.com/watch?v=lCUKQnkjajo)
Pg2 - process groups
Mnesia distributed database (beware!)
“Just sending messages to pids because Erlang is great”
Swarm / Horde

12:40 - How do we handle background tasks?

Started with verk
Recently becoming more comfortable with spinning up GenServers
“The language itself is built to be concurrent.”

15:06 What libraries are we using in prod?

First thing: You don’t need a whole lot because the language is so well designed.
Phoenix - web framework
Ecto - sort of an ORM
Distillery - for releases
Bamboo - for sending emails
Quantum - for task scheduling
Timex - for dates and times, and timezones
Cachex - for caching

18:20- What third party integrations have we attempted

Stripe
Square
Twilio
Mindbody

Always building our own clients. Using HTTPoison

19:58Has Elixir ever saved the day in production?

It’s saved many days by PREVENTING ISSUES. Systems are architected for reliability and fault-tolerance.

21:48 - Where do supervision trees come from? What is OTP?

OTP is an Erlang standard lib
Includes supervision trees, genservers, ETS, and a lot of stuff we don’t even know about!
gen_tcp
Mnesia
dets

23:43- Tips for devs considering running elixir in production.

Jump in and read the docs
Understand how systems boot, distillery releases, config providers, etc.
“Good server monitoring hygiene”
“DIVE IN!” 19:54 Outro

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Dan Ivo...

Season 2 Trailer

Elixir Wizards

07/09/19 • 1 min

We’re excited to announce our season two topic, Elixir Internals. In this season we talk with developers behind some of the most popular Elixir libraries, including Witchcraft, ElixirScript, Distillery, Ecto, and more!

HTTP Requests in Elixir vs. JavaScript with Yordis Prieto & Stephen Chudleigh

Elixir Wizards

10/26/23 • 50 min

In today’s episode, Sundi and Owen are joined by Yordis Prieto and Stephen Chudleigh to compare notes on HTTP requests in Elixir vs. Ruby, JavaScript, Go, and Rust. They cover common pain points when working with APIs, best practices, and lessons that can be learned from other programming languages.

Yordis maintains Elixir's popular Tesla HTTP client library and shares insights from building APIs and maintaining open-source projects. Stephen has experience with Rails and JavaScript, and now works primarily in Elixir. They offer perspectives on testing HTTP requests and working with different libraries.

While Elixir has matured, there is room for improvement - especially around richer struct parsing from HTTP responses. The discussion highlights ongoing efforts to improve the developer experience for HTTP clients in Elixir and other ecosystems.

Topics Discussed in this Episode

HTTP is a protocol - but each language has different implementation methods
Tesla represents requests as middleware that can be modified before sending
Testing HTTP requests can be a challenge due to dependence on outside systems
GraphQL, OpenAPI, and JSON API provide clear request/response formats
Elixir could improve richer parsing from HTTP into structs
Focus on contribution ergonomics lowers barriers for new participants
Maintainers emphasize making contributions easy via templates and clear documentation
APIs drive adoption of standards for client/server contracts
They discuss GraphQL, JSON API, OpenAPI schemas, and other standards that provide clear request/response formats
TypeScript brings types to APIs and helps to validate responses
Yordis notes that Go and Rust make requests simple via tags for mapping JSON to structs
Language collaboration shares strengths from different ecosystems and inspires new libraries and tools for improving the programming experience

Links Mentioned

Special Guests: Stephen Chudleigh and Yordis Prieto.

Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler

Elixir Wizards

12/21/23 • 47 min

In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure.

In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads.

They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project.

Topics discussed in this episode:

Difference between actor model and shared memory concurrency
Isolation of actor state and communication via message passing
BEAM VM design for high concurrency via lightweight processes
GenServers as common abstraction for building stateful actors
GenServer callbacks for message handling and state updates
Agents as similar process abstraction to GenServers
Shared state utilities like ETS for inter-process communication
Global Interpreter Lock in older Ruby VMs
Ractors as initial actor implementation in Ruby mapping to threads
Planned improvements to Ruby concurrency in 3.3
Akka implementation of actor model on JVM using thread scheduling
Limitations of shared memory concurrency on JVM
Project Loom bringing lightweight processes to JVM
Building GenServer behavior in Ruby using metaprogramming
CSP model of communication using channels in Clojure
Differences between BEAM scheduler and thread-based VMs
Comparing Elixir to academic languages like Haskell
Remote and theScore are hiring!

Links mentioned in this episode:

theScore is hiring! https://www.thescore.com/
Remote is also hiring! https://remote.com/
Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji
Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022
Clojure Programming Language https://clojure.org/
Akka https://akka.io/
Go Programming Language https://github.com/golang/go
Proto Actor for Golang https://proto.actor/
RabbitMQ Open-Source Message Broker Software https://github.com/rabbitmq
JVM Project Loom https://github.com/openjdk/loom
Ractor for Ruby https://docs.ruby-lang.org/en/master/ractor_md.html
Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher
Seven Languages in Seven Weeks by Bruce A. Tate
GenServer https://hexdocs.pm/elixir/1.12/GenServer.html
ets https://www.erlang.org/doc/man/ets.html
Elixir in Action by Saša Jurić
Redis https://github.com/redis/redis
Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski
Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users
Xiang's website https://xiangji.me/
Feeling Good: The New Mood Therapy by David D. Burns

Special Guests: Nathan Hessler and Xiang Ji.

Chris McCord and Jason Stiebs on the Future of Phoenix

Elixir Wizards

06/01/23 • 58 min

Phoenix core team members Chris McCord and Jason Stiebs join Elixir Wizards Sundi Myint and Owen Bickford the growth of Phoenix and LiveView, the latest updates, and what they're excited to see in the future. They express excitement for the possibilities of machine learning, AI, and distributed systems and how these emerging technologies will enhance the user experience of Elixir and LiveView applications in the next decade.

Key Topics Discussed in this Episode:

How community contributions and feedback help improve Phoenix LiveView
The addition of function components, declarative assigns, HEEx, and streams
Why Ecto changesets should be used as "fire and forget" data structures
Excitement about machine learning and AI with libraries like NX
The possibility of distributed systems and actors in the future
Verifying and solving issues in the Phoenix and LiveView issue trackers
Why marketing plays a part in the adoption and mindshare of Phoenix
How streams provide a primitive for arbitrarily large dynamic lists
Elixir VM's ability to scale to millions of connections
A creative use of form inputs for associations with dynamic children

Links Mentioned in this Episode:

Fly Site https://fly.io/
Keynote: The Road To LiveView 1.0 by Chris McCord | ElixirConf EU 2023
Keynote: I Was Wrong About LiveView by Jason Stiebs | ElixirConf 2022
Phoenix Site https://www.phoenixframework.org/
Phoenix Github https://github.com/phoenixframework
Two-Story, 10-Room Purple Martin House
Blog: The Road to 2 Million Websocket Connections in Phoenix
Raxx Elixir Webserver Interface https://hexdocs.pm/raxx/0.4.1/readme.html
Livebook Site https://livebook.dev/
Sundi’s 6’x 6’ Phoenix painting
Surface on Hex https://hex.pm/packages/surface
Axon Deep Learning Framework https://hexdocs.pm/axon/Axon.html
Nx Numerical Elixir https://hexdocs.pm/nx/intro-to-nx.html
Phoenix PubSub https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html
Jason Stiebs on Twitter https://twitter.com/peregrine
Jason Stiebs on Mastodon https://merveilles.town/@peregrine

Special Guests: Chris McCord and Jason Stiebs.

Dave Lucia on Rustler – Elixir Internals

Elixir Wizards

09/26/19 • 32 min

Our guest today on the show is Dave Lucia, who is currently the Vice President of Engineering at SimpleBet. He is here as part of Elixir Internals series, to talk to us and all our listeners about Rustler and the contribution he made to the library! According to our guest, Rustler acts as a bridge between Rust and Elixir and allows users to employ the power of Rust within Elixir and a great example of this can be found in Dave's work at SimpleBet. He explains some of this application and the functionality and improvement it offers and the big difference the machine learning models make to this work. Dave also gives us some background to his work and career, previous employment and early explorations of open-source software. He also shares some great tips for problem-solving and learning and improving at programming in Rust. We unpack some of the biggest challenges that faced the creation of Rustler, notable differences between Rust and Elixir and the technical components of the library that the team created. For all this and then some, join us for this great episode!

Key Points From This Episode:

More about our guest and his current work at SimpleBet.
How Dave got started with Elixir while at Bloomberg.
The interesting and beautiful way in which The Outline used Elixir.
Dave's early forays and experiences with open source software.
Problem finding and solving; Dave's tips to those wanting to improve.
Dave's employers' contribution and allowance for open source projects.
Introducing Rustler and what users can do with it!
The biggest challenges of using multiple languages in the backend.
How Rustler works; the core, the code generator and more.
The most important differences between Rust and Elixir.
Dave's best advice and resources for learning and mastering Rust.
And much more!

Links Mentioned in Today’s Episode:

SmartLogic — https://www.smartlogic.io
Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b
Rustler — https://github.com/rusterlium/rustler
SimpleBet — https://simplebet.io
Dave Lucia on Twitter — https://twitter.com/davydog187
Dave Lucia Email — [email protected]
Elixir — https://elixir-lang.org
Python — https://www.python.org
JavaScript — https://www.javascript.com
Rust — https://www.rust-lang.org
Bloomberg — https://www.bloomberg.com
Slack — https://slack.com
Vox Media — https://www.voxmedia.com
The Outline — https://theoutline.com
The Rust Programming Language — https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284
Rust Playground — https://play.rust-lang.org
Elm Compiler — https://github.com/elm/compiler

Special Guest: Dave Lucia.

Telemetry & Observability for Elixir Apps at Cars.com with Zack Kayser & Ethan Gunderson

Elixir Wizards

12/12/24 • 42 min

Zack Kayser and Ethan Gunderson, Software Engineers at Cars Commerce, join the Elixir Wizards to share their expertise on telemetry and observability in large-scale systems. Drawing from their experience at Cars.com—a platform handling high traffic and concurrent users—they discuss the technical and organizational challenges of scaling applications, managing microservices, and implementing effective observability practices.

The conversation highlights the pivotal role observability plays in diagnosing incidents, anticipating system behavior, and asking unplanned questions of a system. Zack and Ethan explore tracing, spans, and the unique challenges introduced by LiveView deployments and WebSocket connections.

They also discuss the benefits of OpenTelemetry as a vendor-agnostic instrumentation tool, the significance of Elixir’s telemetry library, and practical steps for developers starting their observability journey. Additionally, Zack and Ethan introduce their upcoming book, Instrumenting Elixir Applications, which will offer guidance on integrating telemetry and tracing into Elixir projects.