Free Daily Podcast Summary
Elixir Wizards: Daily Summaries Delivered
by SmartLogic LLC
Get key takeaways, quotes, and insights from Elixir Wizards in a 5-minute read. Delivered straight to your inbox.
Latest Episodes
The most recent episodes — sign up to get AI-powered summaries of each one.
- 5 days ago50 min
The State of Hiring and Jobs in Elixir with Greg Medland
In Season 15 episode 3, Charles Suggs sits down with Greg Medland, aka “The Elixir Fixer,” to talk about the current state of hiring and the software jobs market in 2026. Greg shares what he’s seeing from both sides of the hiring process as an Elixir-focused recruiter, from shifting company expectations to the growing importance of specialization, communication skills, and real-world product thinking. We discuss how the market has changed since the 2021–2022 hiring boom, why things feel more uncertain today, and how developers are adapting to a slower, more competitive landscape. The conversation also explores how AI is affecting hiring workflows, résumé quality, technical interviews, and even the rise of fraudulent candidates. Greg explains why human relationships and reputation still matter more than ever, especially in smaller ecosystems like Elixir where community connections carry real weight. Along the way, we talk about what junior developers are up against, why senior engineers with domain expertise continue to stand out, and what developers can do to position themselves more effectively in today’s market. Greg shares practical advice for building a sustainable career, developing a clear professional identity, and navigating a rapidly changing industry. Topics discussed in this episode: The current state of the Elixir job market Hiring trends and market shifts since 2021–2022 How AI is changing hiring and recruiting workflows Fraudulent candidates and AI-generated résumés Domain expertise vs. generalist engineering skills Product thinking and customer-focused development What companies are looking for in 2026 Junior developer challenges in the current market Why senior specialists remain in demand Networking and relationship-building in tech Open source contributions and visibility in the Elixir community Standing out in a crowded hiring environment Résumé quality and application strategies The role of personal branding for developers Remote work trends and geographic hiring patterns Technical interview expectations and evaluation changes Startup vs. enterprise hiring differences Human connection in an increasingly automated industry Career resilience and long-term positioning Building a sustainable software engineering career Links mentioned: Socially Responsible Recruitment https://sr2rec.com/en/ Greg’s LinkedIn https://www.linkedin.com/in/elixirfixer/ Greg's email address: greg@sr2rec.com
- 1 weeks ago47 min
Supervised State Replication in Elixir with Micah Cooper
In Season 15 episode 2, Elixir Wizards Sundi Myint and Charles Suggs chat with Micah Cooper to talk about distributed systems, data replication, and what it actually looks like to build these ideas in Elixir. Micah shares his journey from Ruby to Elixir and walks us through Visor, a library he’s building based on the Viewstamps replication algorithm. Inspired by systems like TigerBeetle, Visor explores how you can replicate state across nodes using GenServers, giving you fault tolerance and recovery without relying entirely on traditional database patterns. We talk about the difference between distributed systems and data replication, where things tend to get misunderstood, and what changes when you start thinking about state this way. The conversation also touches on event sourcing, tradeoffs in system design, and how Elixir’s distributed model makes some of these concepts more approachable than you might expect. Along the way, we talk about building for curiosity, experimenting with new ideas, and how projects like this push the ecosystem forward. Topics discussed in this episode: Building Visor and working with the Viewstamps replication model Replicating GenServer state across nodes Distributed systems vs. data replication Lessons from TigerBeetle and financial system design Event sourcing challenges and tradeoffs Rethinking database-first architectures Snapshotting, recovery, and fault tolerance The role of Elixir’s distributed model Experimentation, learning, and building for curiosity Links mentioned: Micah’s GitHub https://github.com/mrmicahcooper Micah’s GitLab https://gitlab.com/mrmicahcooper The Visor repository: https://gitlab.com/mrmicahcooper/visor Visor Hex Package https://hex.pm/packages/visor Ruby on Rails https://rubyonrails.org/ Phoenix LiveView Framework https://www.phoenixframework.org/ Zig Programming Language https://ziglang.org/ TigerBeetle https://tigerbeetle.com/ TigerBeetle internal docs https://github.com/tigerbeetle/tigerbeetle/tree/main/docs/internals The BEAM https://www.erlang-solutions.com/blog/the-beam-erlangs-virtual-machine/ GenServer https://hexdocs.pm/elixir/GenServer.html Apache Kafka https://github.com/apache/kafka RabbitMQ https://www.rabbitmq.com/ Redpanda https://www.redpanda.com/ SQL https://www.ibm.com/think/topics/structured-query-language Kubernetes https://kubernetes.io/ YAML https://yaml.org/ Nomad Workload Orchestrator https://developer.hashicorp.com/nomad Flutter https://flutter.dev/ Commanded https://hexdocs.pm/commanded/Commanded.html Go Programming Language https://go.dev/ Clojure Programming Language https://clojure.org/ Nebulex https://hexdocs.pm/nebulex/Nebulex.html Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html Cachex https://hexdocs.pm/cachex/Cachex.html libgraph https://hexdocs.pm/libgraph/Graph.html Horde https://hexdocs.pm/horde/Horde.Registry.html NocFree split keyboard https://www.nocfree.com/
- 2 weeks ago41 min
The State of Security in Elixir with Holden Oullette
In the Elixir Wizards season 15 premiere, host Charles Suggs is joined by Holden Oullette, Senior Security Software Engineer at Netflix and maintainer of Sobelow, to talk about how security is evolving in the Elixir ecosystem. We discuss how certain features of the Elixir programming language (like functional patterns and server-side rendering) provide natural immunity against some common vulnerabilities, and what that means as the language continues to grow. Holden shares how tools like Sobelow are adapting and how new technologies like LLMs and Elixir's type system may help to strengthen security practices. We cover supply chain risks, ecosystem-level responsibility and reputation management, and how initiatives like AEGIS are prepping the community for more widespread adoption. We wrap with practical tips for teams to be more security-minded throughout the software development lifecycle without slowing everything down. Key topics discussed in this episode: How Elixir’s design influences secure-by-default development Security tradeoffs between server-side and client-heavy architecture Supply chain risks and what the ecosystem is doing to prepare Static analysis with tools like Sobelow and AST-based pattern matching Where LLMs fit into modern security workflows The role of Elixir’s upcoming type system in improving tooling Securing CI/CD pipelines and production environments Balancing development speed with security requirements Dependency management and vulnerability monitoring The AEGIS Initiative and ecosystem-wide security efforts Links mentioned: Holden’s GitHub https://github.com/houllette Elixir Programming Language https://elixir-lang.org/ Security-focused static analysis for the Phoenix Framework https://github.com/nccgroup/sobelow Code Security for Builders https://semgrep.dev/ Erlang Ecosystems Foundation https://erlef.org/ Phoenix Framework https://www.phoenixframework.org/ WebSockets https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Socket.html https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API Open Worldwide Application Security Project https://owasp.org/ https://github.com/elixir-ecto/ecto Log4j Vulnerability https://www.ncsc.gov.uk/information/log4j-vulnerability-what-everyone-needs-to-know React2Shell Vulnerability https://www.finra.org/guidance/guidance/cybersecurity-advisory-react2shell The Heartbleed Bug https://www.heartbleed.com/ Elixir Type System https://hexdocs.pm/elixir/main/gradual-set-theoretic-types.html Holden Oullette “Securing the Future: A Roadmap to Making Elixir the Safest Language” ElixirConf 2024 https://youtu.be/gpvKxS6sY8Y Aegis Initiative: Supply Chain Security & Compliance Initiative https://security.erlef.org/aegis/ OIDC Tokens https://openid.net/ Anthropic’s Claude Mythos & Cybersecurity https://red.anthropic.com/2026/mythos-preview/ Igniter Code Generation Framework https://github.com/ash-project/igniter https://smartlogic.io/podcast/elixir-wizards/s13-e01-igniter-code-generation-zach-daniel/ Secure-by-default open source software https://www.chainguard.dev/ https://www.docker.com/ https://github.com/dependabot <a href
- Aug 28, 202533 min
Enter the Elixirverse: Season 14 Wrap-Up
Today, the Elixir Wizards wrap up Season 14 “Enter the Elixirverse.” Dan, Charles, and Sundi look back at some common themes: Elixir plays well with others, bridges easily to access languages and tools, and remains a powerful technology for data flow, concurrency, and developer experience. We revisit the popular topics of the year, from types and tooling to AI orchestration and reproducible dev environments, and share what we’re excited to explore next. We also invite your questions and takeaways to help shape future seasons and conference conversations. Season 14 doubles as a handy primer for anyone curious about how Elixir integrates across the stack. Key topics discussed in this episode: Lessons from a season of interoperability Set-theoretic types and what new compiler warnings unlock AI in practice: LLM orchestration, fallbacks, and real-world use SDUI and GraphQL patterns for shipping UI across web/iOS/Android Dataframes in Elixir with Explorer for analytics workflows Python interoperability (ErlPort, PythonX) and when to reach for it Reproducible dev environments with Nix and friends Performance paths: Rustler and Zig for native extensions Bluetooth & Nerves: Blue Heron and hardware integrations DevEx upgrades: LiveView, build pipelines, and standard project setup Observability and ops: Prometheus/Grafana and sensible deployments Community feedback, conferences, and what’s on deck for next season ### Links mentioned in this episode: Cars.com S14E06 SDUI at Scale with Elixir https://youtu.be/nloRcgngT_k?si=g4Zd4N1s56Ronrtw https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html https://wordpress.com/ https://elixir-lang.org/ S14E01 Zigler: Zig NIFs for Elixir https://youtu.be/hSAvWxh26TU?si=d5_5tVuZbNw0KCfT https://ziglang.org/ https://hexdocs.pm/zigler/Zig.html https://github.com/blue-heron/blue_heron https://github.com/elixir-explorer/explorer S14E08 Nix for Elixir Apps https://youtu.be/yymUcgy4OAk?si=BRgTlc2VK5bsIhIf https://nixos.org/ https://nix.dev/ S14E07 Set Theoretic Types in Elixir https://youtu.be/qMmEnXcHxL4?si=Ux2lebiwEp3mc_0e S14E10 Python in Elixir Apps https://youtu.be/SpVLrrWkRqE?si=ld3oQVXVlWHpo7eV https://www.python.org/ https://hexdocs.pm/pythonx/ https://github.com/Pyrlang/Pyrlang https://github.com/erlport/erlport S14E03 LangChain: LLM Integration for Elixir https://youtu.be/OwFaljL3Ptc?si=A0sDs2dzJ0UoE2PY https://github.com/brainlid/langchain S14E04 Nx & Machine Learning in Elixir https://youtu.be/Ju64kAMLlkw?si=zdVnkBTTLHvIZNBm S14E05 Rustler: Bridging Elixir and Rust https://youtu.be/2RBw7B9OfwE?si=aRVYOyxxW8fTmoRA https://github.com/rusterlium/rustler Season 3: Working with Elixir https://youtube.com/playlist?list=PLTDLmInI9YaDbhMRpGuYpboVNbp1Fl9PD&si=hbe7qt4gRUfrMtpj S14E11 Vibe Coding the LoopedIn Crochet App https://youtu.be/DX0SjmPE92g?si=zCBPjS1huRDIeVeP Season 5: Adopting Elixir YouTubeLaunchisode and Outlaws Takeover with Chris Keathley, Amos King, and Anna Neyzberg S13E01
- Aug 14, 202547 min
Elixir DevOps & Interoperability with Dan Ivovich and Charles Suggs
In this episode of Elixir Wizards, host Sundi Myint chats with SmartLogic engineers and fellow Wizards Dan Ivovich and Charles Suggs about the practical tooling that surrounds Elixir in a consultancy setting. We dig into how standardized dev environments, sensible scaffolding, and clear observability help teams ship quickly across many client projects without turning every app into a snowflake. Join us for a grounded tour of what’s working for us today (and what we’ve retired), plus how we evaluate new tech (including AI) through a pragmatic, Elixir-first lens. Key topics discussed in this episode: Standardizing across projects: why consistent environments matter in consultancy work Nix (and flakes) for reproducible dev setups and faster onboarding Igniter to scaffold common patterns (auth, config, workflows) without boilerplate drift Deployment approaches: OTP releases, runtime config, and Ansible playbooks Frontend pipeline evolution: from Brunch/Webpack to esbuild + Tailwind Observability in practice: Prometheus metrics and Grafana dashboards Handling time-series and sensor data When Explorer can be the database Picking the right tool: Elixir where it shines, integrations where it counts Using AI with intention: code exploration, prototypes, and guardrails for IP/security Keeping quality high across multiple codebases: tests, telemetry, and sensible conventions Reducing context-switching costs with shared patterns and playbooks Links mentioned: http://smartlogic.io https://nix.dev/ https://github.com/ash-project/igniter Elixir Wizards S13E01 Igniter with Zach Daniel https://youtu.be/WM9iQlQSF_g https://github.com/elixir-explorer/explorer Elixir Wizards S14E09 Explorer with Chris Grainger https://youtu.be/OqJDsCF0El0 Elixir Wizards S14E08 Nix with Norbert (Nobbz) Melzer https://youtu.be/yymUcgy4OAk https://jqlang.org/ https://github.com/BurntSushi/ripgrep https://github.com/resources/articles/devops/ci-cd https://prometheus.io/ https://capistranorb.com/ https://ansible.com/ https://hexdocs.pm/phoenix/releases.html https://brunch.io/ https://webpack.js.org/loaders/css-loader/ https://tailwindcss.com/ https://sass-lang.com/dart-sass/ https://grafana.com/ https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/ https://www.datadoghq.com/ https://sqlite.org/ Elixir Wizards S14E06 SDUI at Cars.com with Zack Kayser https://youtu.be/nloRcgngT_k https://github.com/features/copilot https://openai.com/codex/ https://www.anthropic.com/claude-code YouTube Video: Vibe Coding TEDCO's RFP https://youtu.be/i1ncgXZJHZs Blog: https://smartlogic.io/blog/how-i-used-ai-to-vibe-code-a-website-called-for-in-tedco-rfp/ Blog: https://smartlogic.io/blog/from-vibe-to-viable-turning-ai-built-prototypes-into-market-ready-mvps/ <a href="https://www.thriftbooks.com/w/e
- Aug 7, 202539 min
Vibe Coding the LoopedIn Crochet App with Kimberly Erni & Pei Pei Wang
Today, co-founders Kimberly Erni and Pei Pei Wang join the Elixir Wizards to discuss their crochet app, LoopedIn. Recognizing a gap in the market for a more user-friendly and interactive crochet pattern experience, they're building an app that makes following patterns easier and more enjoyable for crocheters of all skill levels. They're building features such as step-by-step guidance, video tutorials, and the ability to upload and convert PDF patterns into an interactive format. Kimberly explains how she's leveraging AI tools to vibe code in Elixir and LiveView. They highlight the challenges and successes they encountered while creating a Progressive Web App (PWA) that integrates AI-powered features. They also discuss their user research and testing process, which involved gathering feedback from the crochet community to prioritize features and improve the app's UX. Kimberly and Pei Pei share their thoughts on the potential of AI in the tech industry and how it has assisted them in the development and iteration process. They emphasize the importance of understanding the code generated by AI and the need for proper testing and verification. They offer advice to others looking to create passion projects, stressing the value of finding a partner with complementary skills and shared enthusiasm for the project. Topics discussed in this episode: Discovering a niche: why crochet patterns need a digital makeover Core LoopedIn features: interactive steps, video help, PDF conversion Building a PWA with Elixir & Phoenix LiveView for cross-platform reach Offline support and caching strategies for on-the-go crafting AI-driven pattern parsing: benefits and pitfalls of generated code User research: gathering feedback from beginner to expert crocheters Agile iterations: testing, prioritizing features, and shipping quickly Balancing “vibe coding” with quality assurance and proper test coverage Partnership dynamics: complementary skills and shared passion Monetization approaches for a niche, community-driven app Roadmap highlights: expanded social features, advanced AI tooling, and more Lessons learned: documentation gaps, performance tuning, and UX trade-offs Advice for side projects: start small, validate with users, and iterate Links mentioned: Amigurumis https://www.amigurumi.com/ https://pragmaticstudio.com/phoenix-liveview https://grox.io/about-product/liveview Creating a Local First LiveView App https://www.youtube.com/watch?v=kcafwf14SDo https://capacitorjs.com/docs https://flutter.dev/ https://passion.place/ https://cursor.com/ https://claude.ai/ https://nerves-project.org/ https://crochetapp.web.app/ https://www.figma.com/ Little Red Book App https://www.xiaohongshu.com/ !! Try the LoopedIn app here 👉 https://looped-in.gigalixirapp.com *!!* Add it to your phone like an app: Open the link in Safari Tap the Share button (square with arrow) Tap Add to Home Screen Tap Add Then you can open it like a regular app! 🎉 Leave a comment if you try it! !! We Want to Hear Your Thoughts *!!* Have questions, comments, or topics you'd like us to discuss in our season recap episode? Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9
- Jul 31, 202535 min
Python in Elixir Apps with Victor Björklund
In this episode, Elixir Wizard Charles Suggs sits down with Victor Björklund to map out the landscape of Python integration in Elixir applications. From HTTP APIs and external services to embedded runtimes like ErlPort, PythonX, and the Venomous library, we evaluate each approach’s impact on performance, coupling, and developer experience. Victor draws on real-world examples like Scrapy-based web scraping and the Swedish BankID authentication to illustrate best practices for error handling, process pooling, and effective telemetry across the BEAM boundary. We also tackle the practical side of deployment: packaging Python dependencies in Mix releases, mocking Python calls in tests, and deploying multi-language apps with confidence. Wrapping up, Victor shares his wishlist for even tighter interop (think multiple Python interpreter instances per VM) and offers low-risk entry points, like automating monthly reports, for teams ready to explore the power of Python’s ecosystem within Elixir. Key topics discussed in this episode: Integration methods: HTTP APIs, ports, ErlPort, PythonX, Venomous Performance vs. coupling trade-offs across interop patterns Managing the Global Interpreter Lock (GIL) with process pools Leveraging mature Python libraries (Scrapy, BankID, etc.) Error handling strategies across BEAM↔Python boundaries Testing mixed-language systems: mocks and integration tests Packaging and deploying Python alongside Elixir releases Monitoring and telemetry for multi-language pipelines Functional programming advantages in Elixir workflows Tool selection guidance by project requirements Future possibilities: multiple Python interpreters in one VM Community resources for Python–Elixir interop help Links mentioned: jawdropping.io https://cplusplus.com/ https://www.python.org/ https://react.dev/ https://nodejs.org/en https://erlport.org/ https://hexdocs.pm/pythonx/Pythonx.html https://pyrlang.github.io/Pyrlang/ Python GIL (Global Interpreter Lock): https://realpython.com/python-gil/ https://github.com/devinus/poolboy https://hexdocs.pm/venomous/Venomous.html Try-catch https://syntaxdb.com/ref/python/try-catch https://www.scrapy.org/ https://www.bankid.com/en/ https://www.phoenixframework.org/ https://www.tzeyiing.com/posts/using-a-hunky-poolboy-to-manage-your-python-erlport-processes-in-elixir/ https://medium.com/stuart-engineering/how-we-use-python-within-elixir-486eb4d266f9 https://x.com/bjorklundvictor https://victorbjorklund.com/ https://www.linkedin.com/in/victorbjorklund/ hello@victorbjorklund.com
- Jul 24, 202542 min
Explorer: Data Frames in Elixir with Chris Grainger
In this episode of Elixir Wizards, Charles Suggs sits down with Chris Grainger, co-founder and CTO of Amplified and creator of the Explorer library. Chris explains how Explorer brings the familiar data-frame workflows of R’s dplyr and Python’s pandas into the Elixir world. We explore (pun intended!) how Explorer integrates with Ecto, Nx, and LiveView to build end-to-end data pipelines without leaving the BEAM, and how features like lazy evaluation and distributed frames let you tackle large datasets. Whether you’re generating reports or driving interactive charts in LiveView, Explorer makes tabular data accessible to every Elixir developer. We wrap up by looking ahead to SQL-style backends, ADBC connectivity, and other features on the Explorer roadmap. Key topics discussed in this episode: dplyr- and pandas-inspired data manipulation in Elixir Polars integration via Rust NIFs for blazing performance Immutable data frames and BEAM-friendly concurrency Lazy evaluation to work with arbitrarily large tables Distributed data-frame support for multi-node processing Seamless integration with Ecto schemas and queries Zero-copy interoperability between Explorer and Nx tensors Apache Arrow and ADBC protocols for cross-language I/O Exploring SQL-style backends for remote query execution Building interactive dashboards and charts in LiveView Consolidating ETL workflows into a single Elixir API Streaming data pipelines for memory-efficient processing Tidy data principles and behavior-based API design Real-world use cases: report generation, patent analysis, and more Future roadmap: new backends, query optimizations, and community plugins Links mentioned: https://hexdocs.pm/explorer/Explorer.html https://www.amplified.ai/ https://www.r-project.org/ https://vita.had.co.nz/papers/tidy-data.pdf https://www.tidyverse.org/ https://www.python.org/ https://dplyr.tidyverse.org/ https://go.dev/ https://hexdocs.pm/nx/Nx.html https://github.com/pola-rs/polars https://github.com/rusterlium/rustler https://www.rust-lang.org/ https://www.postgresql.org/ https://hexdocs.pm/ecto/Ecto.html https://www.elastic.co/elasticsearch https://arrow.apache.org/ Chris Grainger & Chris McCord Keynote ElixirConf 2024: https://youtu.be/4qoHPh0obv0 https://dbplyr.tidyverse.org/ https://spark.posit.co/ https://hexdocs.pm/pythonx/Pythonx.html https://hexdocs.pm/vega_lite/VegaLite.html 10 Minutes to Explorer: https://hexdocs.pm/explorer/exploring_explorer.html https://github.com/elixir-nx/scholar https://scikit-learn.org/stable/ https://github.com/cigrainger https://erlef.org/slack-invite/erlef https://bsky.app/profile/cigrainger.bsky.social https://github.com/cigrainger
Get Elixir Wizards summaries in your inbox
Free AI-powered daily recaps. Key takeaways, quotes, and mentions — in a 5-minute read.
Get Free Summaries →Free forever for up to 3 podcasts. No credit card required.
You Might Also Like
Listeners also like.
Thinking Elixir Podcast
ThinkingElixir.com
Elixir Mentor
Jacob Luetzow
Elixir Mix
Charles M Wood
Beam Radio
Lars Wikman
egghead.io developer chats
Joel Hooks and John Lindquist
Software Unscripted
Richard Feldman
Developer Voices
Kris Jenkins
Developer Weekly
Barry Luijbregts
Nerding Out With Viktor
Viktor Petersson
Backend Banter
Boot.dev
Dev Interrupted
LinearB
The Eric Normand Podcast
Eric Normand
About Elixir Wizards
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)
Customized Recaps
AI-powered recaps with compact key takeaways, quotes, and insights.
Straight to Your Inbox
Get key takeaways from Elixir Wizards in a 5-minute read.
Save Hours Every Week
Stay current on your favorite podcasts without falling behind.
Frequently Asked Questions
What is Podzilla's Elixir Wizards daily summary?
It's a free AI-powered email that summarizes new episodes of Elixir Wizards as soon as they're published. You get the key takeaways, notable quotes, and links & mentions — all in a quick read.
How does the Elixir Wizards podcast summary work?
When a new episode drops, our AI transcribes and analyzes it, then generates a personalized summary tailored to your interests and profession. It's delivered to your inbox every morning.
Is this an official Elixir Wizards product?
No. Podzilla is an independent service that summarizes publicly available podcast content. We're not affiliated with or endorsed by SmartLogic LLC.
Can I get summaries of other podcasts too?
Absolutely! The free plan covers up to 3 podcasts. Upgrade to Pro for 15, or Premium for 50. Browse our full catalog at /podcasts.
How often does Elixir Wizards release new episodes?
Elixir Wizards publishes occasional. Our AI generates a summary within hours of each new episode.
What topics does Elixir Wizards cover?
Elixir Wizards covers topics including Technology, Education, How To. Our AI identifies the specific themes in each episode and highlights what matters most to you.
Start getting Elixir Wizards summaries tomorrow morning.
Free forever for up to 3 podcasts. No credit card required.
Free forever for up to 3 podcasts. No credit card required.