Episodios

  • Python in Elixir Apps with Victor Björklund

    Python in Elixir Apps with Victor Björklund
    Jul 31 2025
    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
    Más Menos
    35 m
  • Season 3 Trailer

    Season 3 Trailer
    Nov 19 2019
    Welcome back to Season 3! Our theme this time around is Working with Elixir. Listen for more on our theme, upcoming guests, and our new name.
    Más Menos
    2 m
  • Season 2 Trailer

    Season 2 Trailer
    Jul 9 2019
    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!
    Más Menos
    1 m
  • Smart Software Season 1 Trailer

    Smart Software Season 1 Trailer
    Feb 25 2019
    Welcome to the first season of Smart Software with SmartLogic. We'll be interviewing several companies about how they use Elixir in Production this season. In this preview episode, we introduce ourselves and some of the topics we’ll be covering. Learn more about how SmartLogic uses Phoenix and Elixir. (https://smr.tl/2Hyslu8)
    Más Menos
    1 m
  • Explorer: Data Frames in Elixir with Chris Grainger

    Explorer: Data Frames in Elixir with Chris Grainger
    Jul 24 2025
    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/vegalite/VegaLite.html 10 Minutes to Explorer: https://hexdocs.pm/explorer/exploringexplorer.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
    Más Menos
    43 m
  • Nix for Elixir Apps with Norbert (NobbZ) Melzer

    Nix for Elixir Apps with Norbert (NobbZ) Melzer
    Jul 17 2025
    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/redhatenterpriselinux/8/html/packaginganddistributingsoftware/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)
    Más Menos
    41 m
  • Set Theoretic Types in Elixir with José Valim

    Set Theoretic Types in Elixir with José Valim
    Jul 10 2025
    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/phoenixliveview/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.
    Más Menos
    46 m
  • SDUI at Scale: GraphQL & Elixir at Cars.com with Zack Kayser

    SDUI at Scale: GraphQL & Elixir at Cars.com with Zack Kayser
    Jul 3 2025
    Zack Kayser, Staff Software Engineer at cars.com, joins Elixir Wizards Sundi Myint and Charles Suggs to discuss how Cars.com adopted a server-driven UI (SDUI) architecture powered by Elixir and GraphQL to deliver consistent, updatable interfaces across web, iOS, and Android. We explore why SDUI matters for feature velocity, how a mature design system and schema planning make it feasible, and what it takes, culturally and technically, to move UI logic from client code into a unified backend. Key topics discussed in this episode: SDUI fundamentals and how it differs from traditional server-side rendering GraphQL as the single source of truth for UI components and layouts Defining abstract UI components on the server to eliminate duplicate logic Leveraging a robust design system as the foundation for SDUI success API-first development and cross-team coordination for schema changes Mock data strategies for early UI feedback without breaking clients Handling breaking changes and hot-fix deployments via server-side updates Enabling flexible layouts and A/B testing through server-controlled ordering Balancing server-driven vs. client-managed UI Iterative SDUI rollout versus “big-bang” migrations in large codebases Using type specs and Dialyxir for clear cross-team communication Integration testing at the GraphQL layer to catch UI regressions early Quality engineering’s role in validating server-driven interfaces Production rollback strategies across web and native platforms Considerations for greenfield projects adopting SDUI from day one Zack and Ethan's upcoming Instrumenting Elixir Apps book Links mentioned: https://cars.com https://github.com/absinthe-graphql/absinthe Telemetry & Observability for Elixir Apps Ep: https://youtu.be/1V2xEPqqCso https://www.phoenixframework.org/blog/phoenix-liveview-1.0-released https://hexdocs.pm/phoenixliveview/assigns-eex.html https://graphql.org/ https://tailwindcss.com/ https://github.com/jeremyjh/dialyxir https://github.com/rrrene/credo GraphQL Schema https://graphql.org/learn/schema/ SwiftUI https://developer.apple.com/documentation/swiftui/ Kotlin https://kotlinlang.org/ https://medium.com/airbnb-engineering/a-deep-dive-into-airbnbs-server-driven-ui-system-842244c5f5 Zack’s Twitter: https://x.com/kayserzl/ Zack’s LinkedIn: https://www.linkedin.com/in/zack-kayser-93b96b88 Special Guest: Zack Kayser.
    Más Menos
    49 m