Elixir Wizards

SmartLogic LLC
  • 4,9 (22)
  • ТЕХНОЛОГИИ
  • ЕЖЕНЕДЕЛЬНО

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)

  1. Python in Elixir Apps with Victor Björklund

    -4 ДН.

    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 мин.
  2. Explorer: Data Frames in Elixir with Chris Grainger

    24 ИЮЛ.

    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/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

    43 мин.
  3. Nix for Elixir Apps with Norbert (NobbZ) Melzer

    17 ИЮЛ.

    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/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)

    41 мин.
  4. Set Theoretic Types in Elixir with José Valim

    10 ИЮЛ.

    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/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.

    46 мин.
  5. SDUI at Scale: GraphQL & Elixir at Cars.com with Zack Kayser

    3 ИЮЛ.

    SDUI at Scale: GraphQL & Elixir at Cars.com with Zack Kayser

    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.

    49 мин.
  6. Rustler: Bridging Elixir and Rust with Sonny Scroggin

    26 ИЮН.

    Rustler: Bridging Elixir and Rust with Sonny Scroggin

    Rustler Core Team Member Sonny Scroggin joins Elixir Wizards Sundi Myint and Charles Suggs. Rustler serves as a bridge to write Native Implemented Functions (NIFs) in Rust that can be called from Elixir code. This combo leverages Rust's performance and memory safety while maintaining Elixir's fault tolerance and concurrency model, creating a powerful solution for CPU-intensive operations within Elixir applications. Sonny provides guidance on when developers should consider using NIFs versus other approaches like ports or external services and highlights the considerations needed when stepping outside Elixir's standard execution model into native code. Looking toward the future, Sonny discusses exciting developments for Rustler, including an improved asynchronous NIF interface, API modernization efforts, and better tooling. While Rust offers tremendous performance benefits for specific use cases, Sonny emphasizes that Elixir's dynamic nature and the BEAM's capabilities for distributed systems remain unmatched for many applications. Rustler simply provides another powerful tool that expands what developers can accomplish within the Elixir ecosystem. Key topics discussed in this episode: Rust as a "high-level low-level language" with memory safety NIFs (Native Implemented Functions) in the BEAM virtual machine Rustler's role simplifying Rust-Elixir integration with macros CPU-intensive operations as primary NIF use cases Beam scheduler interaction considerations with native code Dirty schedulers for longer-running NIFs in OTP 20+ Memory safety advantages of Rust for NIFs Development workflow using Mix tasks for Rustler Common pitfalls when first working with Rust Error handling improvements possible with Rustler NIFs Differences between ports, NIFs, and external services Asynchronous programming approaches in Rust versus Elixir Tokyo runtime integration for asynchronous operations Static NIFs for mobile device compatibility Upcoming CLI tooling to simplify Rustler development Rustler's API modernization efforts for better ergonomics Thread pool sharing across multiple NIFs Wasm integration possibilities for the BEAM Compile-time safety versus dynamic runtime capabilities Performance considerations when implementing NIFs Compiler-assisted memory management in Rust Automatic encoding/decoding between Rust and Elixir types The importance of proper error handling Real-world application in high-traffic authentication servers Community resources for learning Rustler Links mentioned: https://github.com/rusterlium/rustler https://github.com/rust-lang/rust https://www.angelfire.lycos.com/ https://www.webdesignmuseum.org/flash-websites https://www.php.net/ https://xmpp.org/ https://jabberd2.org/ Geocities: https://cybercultural.com/p/geocities-1995/ (fun fact: when you search Geocities on Google, the results page is in Comic Sans font.) https://bleacherreport.com/ https://hexdocs.pm/jose/readme.html https://github.com/rust-lang/rust-bindgen Erlang Ports: https://www.erlang.org/doc/system/cport.html Erlang ETFs (External Term Format): https://www.erlang.org/doc/apps/erts/erlextdist.html Elixir gRPC https://github.com/elixir-grpc/grpc gRPC (“Remote Proceduce Call”): https://grpc.io/ dirtycpu.ex https://github.com/E-xyza/zigler/blob/main/lib/zig/nif/dirty_cpu.ex ets https://www.erlang.org/doc/apps/stdlib/ets.html Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html VPPs (Virtual Power Plants): https://www.energy.gov/lpo/virtual-power-plants https://nixos.org/ WASM WebAssembly with Elixir: https://github.com/RoyalIcing/Orb Rust Tokio https://tokio.rs/ Getting Started: https://hexdocs.pm/rustler/0.17.0/Mix.Tasks.Rustler.New.html https://rustup.rs/ Special Guest: Sonny Scroggin.

    49 мин.
  7. Nx and Machine Learning in Elixir with Sean Moriarity

    19 ИЮН.

    Nx and Machine Learning in Elixir with Sean Moriarity

    Today on Elixir Wizards, hosts Sundi Myint and Charles Suggs catch up with Sean Moriarity, co-creator of the Nx project and author of Machine Learning in Elixir. Sean reflects on his transition from the military to a civilian job building large language models (LLMs) for software. He explains how the Elixir ML landscape has evolved since the rise of ChatGPT, shifting from building native model implementations toward orchestrating best-in-class tools. We discuss the pragmatics of adding ML to Elixir apps: when to start with out-of-the-box LLMs vs. rolling your own, how to hook into Python-based libraries, and how to tap Elixir’s distributed computing for scalable workloads. Sean closes with advice for developers embarking on Elixir ML projects, from picking motivating use cases to experimenting with domain-specific languages for AI-driven workflows. Key topics discussed in this episode: The evolution of the Nx (Numerical Elixir) project and what's new with ML in Elixir Treating Elixir as an orchestration layer for external ML tools When to rely on off-the-shelf LLMs vs. custom models Strategies for integrating Elixir with Python-based ML libraries Leveraging Elixir’s distributed computing strengths for ML tasks Starting ML projects with existing data considerations Synthetic data generation using large language models Exploring DSLs to streamline AI-powered business logic Balancing custom frameworks and service-based approaches in production Pragmatic advice for getting started with ML in Elixir Links mentioned: https://hexdocs.pm/nx/intro-to-nx.html https://pragprog.com/titles/smelixir/machine-learning-in-elixir/ https://magic.dev/ https://smartlogic.io/podcast/elixir-wizards/s10-e10-sean-moriarity-machine-learning-elixir/ Pragmatic Bookshelf: https://pragprog.com/ ONNX Runtime Bindings for Elixir: https://github.com/elixir-nx/ortex https://github.com/elixir-nx/bumblebee Silero Voice Activity Detector: https://github.com/snakers4/silero-vad Paulo Valente Graph Splitting Article: https://dockyard.com/blog/2024/11/06/2024/nx-sharding-update-part-1 Thomas Millar's Twitter https://x.com/thmsmlr https://github.com/thmsmlr/instructorex https://phoenix.new/ https://tidewave.ai/ https://en.wikipedia.org/wiki/BERT(language_model) Talk: PyTorch: Fast Differentiable Dynamic Graphs in Python (https://www.youtube.com/watch?v=am895oU6mmY) by Soumith Chintala https://hexdocs.pm/axon/Axon.html https://hexdocs.pm/exla/EXLA.html VLM (Vision Language Models Explained): https://huggingface.co/blog/vlms https://github.com/ggml-org/llama.cpp Vector Search in Elixir: https://github.com/elixir-nx/hnswlib https://www.amplified.ai/ Llama 4 https://mistral.ai/ Mistral Open-Source LLMs: https://mistral.ai/ https://github.com/openai/whisper Elixir Wizards Season 5: Adopting Elixir https://smartlogic.io/podcast/elixir-wizards/season-five https://docs.ray.io/en/latest/ray-overview/index.html https://hexdocs.pm/flame/FLAME.html https://firecracker-microvm.github.io/ https://fly.io/ https://kubernetes.io/ WireGuard VPNs https://www.wireguard.com/ https://hexdocs.pm/phoenixpubsub/Phoenix.PubSub.html https://www.manning.com/books/deep-learning-with-python Code BEAM 2025 Keynote: Designing LLM Native Systems - Sean Moriarity Ash Framework https://ash-hq.org/ Sean’s Twitter: https://x.com/seanmoriarity Sean’s Personal Blog: https://seanmoriarity.com/ Erlang Ecosystems Foundation Slack: https://erlef.org/slack-invite/erlef Elixir Forum https://elixirforum.com/ Sean’s LinkedIn: https://www.linkedin.com/in/sean-m-ba231a149/ Special Guest: Sean Moriarity.

    44 мин.
  8. LangChain: LLM Integration for Elixir Apps with Mark Ericksen

    12 ИЮН.

    LangChain: LLM Integration for Elixir Apps with Mark Ericksen

    Mark Ericksen, creator of the Elixir LangChain framework, joins the Elixir Wizards to talk about LLM integration in Elixir apps. He explains how LangChain abstracts away the quirks of different AI providers (OpenAI, Anthropic’s Claude, Google’s Gemini) so you can work with any LLM in one more consistent API. We dig into core features like conversation chaining, tool execution, automatic retries, and production-grade fallback strategies. Mark shares his experiences maintaining LangChain in a fast-moving AI world: how it shields developers from API drift, manages token budgets, and handles rate limits and outages. He also reveals testing tactics for non-deterministic AI outputs, configuration tips for custom authentication, and the highlights of the new v0.4 release, including “content parts” support for thinking-style models. Key topics discussed in this episode: • Abstracting LLM APIs behind a unified Elixir interface • Building and managing conversation chains across multiple models • Exposing application functionality to LLMs through tool integrations • Automatic retries and fallback chains for production resilience • Supporting a variety of LLM providers • Tracking and optimizing token usage for cost control • Configuring API keys, authentication, and provider-specific settings • Handling rate limits and service outages with degradation • Processing multimodal inputs (text, images) in Langchain workflows • Extracting structured data from unstructured LLM responses • Leveraging “content parts” in v0.4 for advanced thinking-model support • Debugging LLM interactions using verbose logging and telemetry • Kickstarting experiments in LiveBook notebooks and demos • Comparing Elixir LangChain to the original Python implementation • Crafting human-in-the-loop workflows for interactive AI features • Integrating Langchain with the Ash framework for chat-driven interfaces • Contributing to open-source LLM adapters and staying ahead of API changes • Building fallback chains (e.g., OpenAI → Azure) for seamless continuity • Embedding business logic decisions directly into AI-powered tools • Summarization techniques for token efficiency in ongoing conversations • Batch processing tactics to leverage lower-cost API rate tiers • Real-world lessons on maintaining uptime amid LLM service disruptions Links mentioned: https://rubyonrails.org/ https://fly.io/ https://zionnationalpark.com/ https://podcast.thinkingelixir.com/ https://github.com/brainlid/langchain https://openai.com/ https://claude.ai/ https://gemini.google.com/ https://www.anthropic.com/ Vertex AI Studio https://cloud.google.com/generative-ai-studio https://www.perplexity.ai/ https://azure.microsoft.com/ https://hexdocs.pm/ecto/Ecto.html https://oban.pro/ Chris McCord’s ElixirConf EU 2025 Talk https://www.youtube.com/watch?v=ojL_VHc4gLk Getting started: https://hexdocs.pm/langchain/gettingstarted.html https://ash-hq.org/ https://hex.pm/packages/langchain https://hexdocs.pm/igniter/readme.html https://www.youtube.com/watch?v=WM9iQlQSFg @brainlid on Twitter and BlueSky Special Guest: Mark Ericksen.

    38 мин.
См. все (196)

Трейлеры

4,9
из 5
Оценок: 22

Об этом подкасте

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)

Информация

  • Автор
    SmartLogic LLC
  • Годы выхода
    2019 - 2025
  • Выпуски
    196
  • Ограничения
    Без ненормативной лексики
  • Авторские права
    © 2025 SmartLogic LLC
  • Сайт подкаста
    Elixir Wizards

Вам может также понравиться