Elixir Wizards

SmartLogic LLC

Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software development landscape. Each episode explores how modern systems are built, from distributed architectures and infrastructure to developer workflows, security, and emerging technologies like AI. While rooted in the Elixir ecosystem, the show often branches out to compare approaches across languages, platforms, and disciplines. Whether you’re working in Elixir or just interested in how software is evolving, Elixir Wizards offers practical insights and thoughtful perspectives from the people building today’s systems.

  1. The State of Security in Elixir with Holden Oullette

    4 DAYS AGO

    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 https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-models.html https://nixos.org/ https://smartlogic.io/podcast/elixir-wizards/s14-e08-nix-for-elixir-apps/ https://fedoraproject.org/ https://kubernetes.io/ https://netflix.github.io/chaosmonkey/ https://netflixtechblog.com/all?topic=chaos-monkey Special Guest: Holden Oullette.

    42 min
  2. Enter the Elixirverse: Season 14 Wrap-Up

    28/08/2025

    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 Igniter: Elixir Code Generation https://youtu.be/WM9iQlQSF_g?si=e0CAiML2qC2SxmdL Season 8: Elixir in a Polyglot Environment https://youtube.com/playlist?list=PLTDLmInI9YaAPlvMd-RDp6LWFjI67wOGN&si=YCI7WLA8qozD57iw !! We Want to Hear Your Thoughts *!!* Have questions, comments, or topics you'd like us to discuss on the podcast? Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

    34 min
  3. Elixir DevOps & Interoperability with Dan Ivovich and Charles Suggs

    14/08/2025

    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/ https://www.thriftbooks.com/w/eragon-by-christopher-paolini/246801 https://tidewave.ai/ !! 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

    47 min
  4. Vibe Coding the LoopedIn Crochet App with Kimberly Erni & Pei Pei Wang

    07/08/2025

    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

    40 min
  5. Python in Elixir Apps with Victor Björklund

    31/07/2025

    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

    35 min
  6. Explorer: Data Frames in Elixir with Chris Grainger

    24/07/2025

    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

    43 min
  7. Nix for Elixir Apps with Norbert (NobbZ) Melzer

    17/07/2025

    Nix for Elixir Apps with Norbert (NobbZ) Melzer

    In this episode of Elixir Wizards, Dan Ivovich and Charles Suggs sit down with Norbert “NobbZ” Melzer to discuss how Nix enables reproducible builds, consistent development environments, and reliable deployments for Elixir projects. Norbert shares his journey from Ruby to Elixir, contrasts Nix with NixOS, and walks us through flakes, nix-shell workflows, sandboxed builds, and rollback capabilities. Along the way, we cover real-world tips for managing Hex authentication, integrating Nix into CI/CD, wrapping Mix releases in Docker, and avoiding common pitfalls, such as flake performance traps. Whether you’re spinning up your first dev shell or rolling out a production release on NixOS, you’ll come away with a clear, gradual adoption path and pointers to the community mentors and resources that can help you succeed. Key topics discussed in this episode: Reproducible, sandboxed builds vs. traditional package managers Nix flakes for locked dependency graphs and version pinning nix-shell: creating consistent development environments across teams Rollback and immutable deployment strategies with Nix/NixOS Integrating Nix with the Elixir toolchain: Hex, Mix, and CI/CD pipelines Flakes vs. standard shells: when and how to transition Handling private Hex repositories and authentication in Nix Cross-platform support (macOS/Darwin, Linux variants) Channels, overlays, and overrides for customizing builds Dockerizing Elixir releases using Nix-based images Home Manager for personal environment configuration Security patching workflows in a Nix-managed infrastructure Common pitfalls: flake performance, sandbox workarounds, and symlink behavior Community resources and the importance of human mentorship Links mentioned: https://jobrad-loop.com/ https://nixos.org/ https://nix.dev/ https://nix.dev/manual/nix/2.18/command-ref/nix-shell https://github.com/nix-darwin/nix-darwin https://asdf-vm.com/ https://go.dev/ https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/packaging_and_distributing_software/introduction-to-rpm_packaging-and-distributing-software Nix Flake templates for Elixir https://github.com/jurraca/elixir-templates https://www.docker.com/ https://www.sudo.ws/ https://ubuntu.com/ https://archlinux.org/ Nobbz’s blog https://blog.nobbz.dev/blog/ https://ayats.org/blog/nix-workflow @nobbz.dev on BlueSky @NobbZ1981 on Twitter https://www.linkedin.com/in/norbert-melzer/ https://youtu.be/HbtbdLolHeM?si=6M7fulTQZmuWGGCM (talk on CodeBEAM)

    41 min
  8. Set Theoretic Types in Elixir with José Valim

    10/07/2025

    Set Theoretic Types in Elixir with José Valim

    Elixir creator José Valim returns to the podcast to unpack the latest developments in Elixir’s set-theoretic type system and how it is slotting into existing code without requiring annotations. We discuss familiar compiler warnings, new warnings based on inferred types, a phased rollout in v1.19/v1.20 that preserves backward compatibility, performance profiling the type checks across large codebases, and precise typing for maps as both records and dictionaries. José also touches on CNRS academic collaborations, upcoming LSP/tooling enhancements, and future possibilities like optional annotations and guard-clause typing, all while keeping Elixir’s dynamic, developer-friendly experience front and center. Key topics discussed in this episode: Set-theoretic typing (union, intersection, difference) Compiler-driven inference with zero annotations Phased rollout strategy in 1.19 and 1.20 Performance profiling for large codebases Map typing as records and dictionaries Exhaustivity checks and behavioral typing in GenServers Language Server Protocol & tooling updates Future optional annotations and guard-clause typing CNRS collaboration for theoretical foundations Clear error messages and false-positive reduction Community-driven feedback and iterative improvements Links mentioned: https://github.com/elixir-nx https://livebook.dev/ https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html https://hexdocs.pm/elixir/main/gradual-set-theoretic-types.html https://hexdocs.pm/dialyxir/0.4.0/readme.html https://remote.com/ Draw the Owl meme: https://i.imgur.com/rCr9A.png https://dashbit.co/blog/data-evolution-with-set-theoretic-types https://hexdocs.pm/ecto/Ecto.html https://github.com/elixir-lsp/elixir-ls Special Guest: José Valim.

    46 min
See All (200)

Trailers

About

Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software development landscape. Each episode explores how modern systems are built, from distributed architectures and infrastructure to developer workflows, security, and emerging technologies like AI. While rooted in the Elixir ecosystem, the show often branches out to compare approaches across languages, platforms, and disciplines. Whether you’re working in Elixir or just interested in how software is evolving, Elixir Wizards offers practical insights and thoughtful perspectives from the people building today’s systems.

Information

  • Creator
    SmartLogic LLC
  • Years Active
    2019 - 2026
  • Episodes
    200
  • Rating
    Clean
  • Copyright
    © 2026 SmartLogic LLC
  • Show Website
    Elixir Wizards

You Might Also Like