Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast)

Elixir Wizards

Player FM - Internet Radio Done Right

79 subscribers

Web Development

اضافه شده در six سال پیش

محتوای ارائه شده توسط SmartLogic LLC. تمام محتوای پادکست شامل قسمت‌ها، گرافیک‌ها و توضیحات پادکست مستقیماً توسط SmartLogic LLC یا شریک پلتفرم پادکست آن‌ها آپلود و ارائه می‌شوند. اگر فکر می‌کنید شخصی بدون اجازه شما از اثر دارای حق نسخه‌برداری شما استفاده می‌کند، می‌توانید روندی که در اینجا شرح داده شده است را دنبال کنید.https://fa.player.fm/legal

Accidental CEO Podcast

1
72: If You Want to Grow—Stop Fixing the Wrong Problem 16:32

27 روز پیش16:32

پخش در آینده

لیست ها

پسندیدن

دوست داشته شد

16:32

You’re busy—but are you actually growing? In this episode, Nata Salvatori exposes a trap that’s costing service providers time, money, and sanity: chasing busywork that feels productive but doesn’t move the needle. She walks through a clear, five-step growth path—from clarifying your offer, validating through real sales, delivering sustainably, building repeatable systems, to scaling confidently. You’ll learn: How to spot and ditch “fake work” Why clarity beats complexity every time How to use real feedback to validate your offers Delivery tips that prevent burnout System creation that enables scaling How to honor your current phase of growth 📌 Ready to stop spinning your wheels and make real moves? Map your phase, pick your next action, and don’t be afraid to ask for help: 👉 accidentalceo.co/coaching Support the show…

۲ سال پیش 1:09:04

MP3•خانه قسمت

For the final episode of Elixir Wizards’ Season 11 “Branching Out from Elixir,” we’re featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language.

This episode covers the origins of creating a language, its influences, and how goals shape the tradeoffs in programming language design. José and Richard share anecdotes from their experiences guiding the evolution of Elixir and Roc. The discussion provides an insightful look at the experimentation and learning involved in crafting new languages.

Topics discussed in this episode

What inspires the creation of a new programming language
Goals and use cases for a programming language
Influences from Elm, Rust, Haskell, Go, OCaml, and more
Tradeoffs involved in expressiveness of type systems
Opportunistic mutation for performance gains in a functional language
Minimum version selection for dependency resolution
Build time considerations with type checking and monomorphization
Design experiments and rolling back features that don’t work out
History from the first simple interpreter to today's real programming language
Design considerations around package management and versioning
Participation in Advent of Code to gain new users and feedback
Providing performance optimization tools to users in the future
Tradeoffs involved in picking integer types and arithmetic
Comparing floats and equality checks on dictionaries
Using abilities to customize equality for custom types
Ensuring availability of multiple package versions for incremental upgrades
Treating major version bumps as separate artifacts
Roc's focus on single-threaded performance

Links mentioned in this episode

Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted
Roc Programming Language https://www.roc-lang.org/
Roc Lang on Github https://github.com/roc-lang/roc
Elm Programming Language https://elm-lang.org/
Elm in Action by Richard Feldman https://www.manning.com/books/elm-in-action
Richard Feldman on Github https://github.com/rtfeldman
Lua Programming Language https://www.lua.org/
Vimscript Guide https://google.github.io/styleguide/vimscriptfull.xml
OCaml Programming Language https://ocaml.org/
Advent of Code https://adventofcode.com/
Roc Language on Twitter https://twitter.com/roc_lang
Richard Feldman on Twitter https://twitter.com/rtfeldman
Roc Zulip Chat https://roc.zulipchat.com
Clojure Programming Language https://clojure.org/
Talk: Persistent Data Structures and Managed References by Rich Hickey https://www.youtube.com/watch?v=toD45DtVCFM
Koka Programming Language https://koka-lang.github.io/koka/doc/index.html
Flix Programming Language https://flix.dev/
Clojure Transients https://clojure.org/reference/transients
Haskell Software Transactional Memory https://wiki.haskell.org/Software_transactional_memory
Rust Traits https://doc.rust-lang.org/book/ch10-02-traits.html
CoffeeScript https://coffeescript.org/
Cargo Package Management https://doc.rust-lang.org/book/ch01-03-hello-cargo.html
Versioning in Golang https://research.swtch.com/vgo-principles

Special Guests: José Valim and Richard Feldman.

199 قسمت

#Web Development #Software Development #Elixir #Elixirlang #Phoenix #Webdev #SmartLogic LLC #Tech #Podcasting Education #Web App #Mobile App #JavaScript #Ruby On Rails #Programming #Code #Java

Elixir Wizards

Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast)

Elixir Wizards

79 subscribers

published ۲ سال پیش

اشتراک گذاری

MP3•خانه قسمت

Topics discussed in this episode

What inspires the creation of a new programming language
Goals and use cases for a programming language
Influences from Elm, Rust, Haskell, Go, OCaml, and more
Tradeoffs involved in expressiveness of type systems
Opportunistic mutation for performance gains in a functional language
Minimum version selection for dependency resolution
Build time considerations with type checking and monomorphization
Design experiments and rolling back features that don’t work out
History from the first simple interpreter to today's real programming language
Design considerations around package management and versioning
Participation in Advent of Code to gain new users and feedback
Providing performance optimization tools to users in the future
Tradeoffs involved in picking integer types and arithmetic
Comparing floats and equality checks on dictionaries
Using abilities to customize equality for custom types
Ensuring availability of multiple package versions for incremental upgrades
Treating major version bumps as separate artifacts
Roc's focus on single-threaded performance

Links mentioned in this episode

Special Guests: José Valim and Richard Feldman.

199 قسمت

#Web Development #Software Development #Elixir #Elixirlang #Phoenix #Webdev #SmartLogic LLC #Tech #Podcasting Education #Web App #Mobile App #JavaScript #Ruby On Rails #Programming #Code #Java

همه قسمت ها

Elixir Wizards

1
Explorer: Data Frames in Elixir with Chris Grainger 42:55

۵ روز پیش42:55

42:55

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…

Elixir Wizards

1
Nix for Elixir Apps with Norbert (NobbZ) Melzer 41:15

12 روز پیش41:15

41:15

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

Elixir Wizards

1
Set Theoretic Types in Elixir with José Valim 45:40

19 روز پیش45:40

45:40

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

Elixir Wizards

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

26 روز پیش49:18

49:18

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

Elixir Wizards

1
Rustler: Bridging Elixir and Rust with Sonny Scroggin 48:58

۵ weeks پیش48:58

48:58

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/c_port.html Erlang ETFs (External Term Format): https://www.erlang.org/doc/apps/erts/erl_ext_dist.html Elixir gRPC https://github.com/elixir-grpc/grpc gRPC (“Remote Proceduce Call”): https://grpc.io/ dirty_cpu.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.…

Elixir Wizards

1
Nx and Machine Learning in Elixir with Sean Moriarity 44:21

۶ weeks پیش44:21

44:21

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/instructor_ex https://phoenix.new/ https://tidewave.ai/ https://en.wikipedia.org/wiki/BERT_(language_model) Talk: PyTorch: Fast Differentiable Dynamic Graphs in Python 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.…

Elixir Wizards

1
LangChain: LLM Integration for Elixir Apps with Mark Ericksen 38:18

۷ weeks پیش38:18

38:18

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/getting_started.html https://ash-hq.org/ https://hex.pm/packages/langchain https://hexdocs.pm/igniter/readme.html https://www.youtube.com/watch?v=WM9iQlQSF_g @brainlid on Twitter and BlueSky Special Guest: Mark Ericksen.…

Elixir Wizards

1
Blue Heron: Bluetooth Low Energy (BLE) for Elixir & Nerves with Connor Rigby 46:16

۸ weeks پیش46:16

46:16

Connor Rigby joins the Elixir Wizards to talk about Blue Heron BLE (Bluetooth Low Energy) support for Elixir apps. Blue Heron implements the BLE specs in pure Elixir, leveraging binary pattern matching and concurrent message processing to handle Bluetooth protocols. Unlike most solutions that require C ports or NIFs, Blue Heron runs entirely in user space, so it works seamlessly in both Nerves-based embedded projects and (eventually) desktop Elixir applications. We discuss how Nerves development differs from building Phoenix apps. Connor shares challenges he's experienced with hardware compatibility, where some chips only partially implement the spec, and he discusses the surprisingly deep (but sometimes incomplete) world of BLE device profiles. His tip for anyone entering the BLE space: read the official spec instead of trusting secondhand blog posts. Tools like Nerves LiveBook give you hands-on examples, so you can get a BLE prototype running on a Raspberry Pi and your phone in no time. Key topics discussed in this episode: Blue Heron origins and “bird” naming convention BLE vs. Bluetooth Classic: core differences Pure Elixir implementation—no C dependencies Binary pattern matching for packet parsing Hardware transport options: UART, SPI, USB, SDIO GenServer patterns in Nerves vs. Phoenix Linux requirement and power-consumption trade-offs GATT (Generic Attribute Table) implementation patterns SQLite integration for Nerves apps Hardware chip quirks and spec compliance Manufacturer-specific commands and workarounds BLE device profiles and spec gaps Security Management Profile (SMP) for encryption Device connection and pairing workflows Web vs. embedded development differences Where to get started: hardware recommendations and docs Links mentioned: https://github.com/ConnorRigby/ https://github.com/blue-heron/ https://nerves-project.org/ BLE (Bluetooth Low Energy) https://en.wikipedia.org/wiki/Bluetooth_Low_Energy https://developer.apple.com/ibeacon/ https://learnyousomeerlang.com/building-otp-applications Linux https://www.linux.org/ HCI (Host Controller Interface) https://en.wikipedia.org/wiki/Host_controller_interface Circuits UART Library https://hexdocs.pm/circuits_uart/readme.html SPI (Serial Peripheral Interface) https://github.com/elixir-circuits/circuits_spi SDIO (Secure Digital Input Output https://en.wikipedia.org/wiki/SDIO Raspberry Pi https://www.raspberrypi.com/ Coral SoM Dev Board https://coral.ai/products/dev-board/ BeagleBone Single-Board Linux Computer https://www.beagleboard.org/boards/beaglebone-black https://www.bluetooth.com/bluetooth-resources/intro-to-bluetooth-gap-gatt/ Genservers https://hexdocs.pm/elixir/1.12/GenServer.html https://hexdocs.pm/ecto/Ecto.html https://github.com/elixir-sqlite/ecto_sqlite3 https://github.com/nerves-livebook/nerves_livebook Special Guest: Connor Rigby.…

Elixir Wizards

1
Zigler: Zig NIFs for Elixir with Isaac Yonemoto 43:00

۹ weeks پیش43:00

43:00

In the Season 14 premiere, hosts Dan Ivovich and Sundi Myint chat with Isaac Yonemoto, creator of the Zigler library, to explore how Zigler brings Zig’s performance and safety to Elixir through Native Implemented Functions (NIFs). Isaac walks through the core design of Zigler and how it auto-generates the Elixir-to-Zig bridge, enforces type safety, and exposes multiple execution modes (normal, dirty, threaded). The conversation covers real-world applications, from SIMD-powered token selection for LLM hardware acceleration to OTP-style fault tolerance in low-level code. Isaac shares his own journey: stepping back from professional software work to launch a biotech startup focused on reducing drug manufacturing costs while continuing to maintain Zigler and even leveraging Elixir for bioinformatics pipelines. Topics discussed in this episode: What is the Zigler library and what does it do? What does it mean to run a "dirty NIF"? Async mode is temporarily removed from Zig (therefore, yielding NIFs is temporarily deprecated in Zigler) Zigler’s three execution modes (normal, dirty, and threaded) and how you switch modes with a single config change Isaac’s journey from professional software work to launching a biotech startup How Isaac leverages Elixir in bioinformatics pipelines at his startup LLM hardware acceleration using Zigler NIFs and SIMD-powered token picking Fault-tolerant load balancing of NIF workloads via OTP principles Transparent handling and recovery from hardware failures through monitoring Potential future memory-safety features in Zig and their implications The Elixir-based borrow-checker prototype: purpose and design Unit-checking for scientific computations to enforce correctness New OS support in Zigler 0.14: macOS, Windows, and FreeBSD Inline Zig code authoring directly within Elixir modules Isaac's commitment to maintain Zigler through its 1.0 release (...and beyond?) Links mentioned: https://github.com/E-xyza/zigler https://github.com/ziglang/zig https://vidalalabs.com/ Zig Programming Language: https://ziglang.org/ https://obsidian.md/ https://hexdocs.pm/elixir/macros.html https://erlang.org/documentation/doc-4.7.3/doc/extensions/macros.html A Deep Dive Into the Elixir AST: https://dorgan.ar/posts/2021/04/the_elixir_ast/ https://www.erlang.org/doc/system/nif.html https://nodejs.org/en Llama Open-Source LLM: https://www.llama.com/ Mixtral Open-Source LLM: https://mistral.ai/news/mixtral-of-experts https://Fly.io SIMD: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data https://opentrons.com/ CI/CD: https://en.wikipedia.org/wiki/CI/CD https://hexdocs.pm/zigler/Zig.html http://www.x.com/DNAutics https://bsky.app/profile/dnautics.bsky.social…

Elixir Wizards

1
Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc 54:19

31 weeks پیش54:19

54:19

For the Season 13 finale, Elixir Wizards Dan and Charles are joined by Spin42 Engineers Marc Lainez, Thibault Poncelet, and Loïc Vigneron to discuss their work retrofitting a 2007 VW Polo and creating an Open Vehicle Control System (OVCS). Using Elixir, Nerves, and Raspberry Pis, the team is reimagining vehicle technology to extend the lifespan of older cars and reduce waste—all while making the process approachable and open source. The Spin42 team shares the technical details behind OVCS and how they use Elixir and Nerves to interact with the CAN bus and build a Vehicle Management System (VMS) to coordinate various vehicle components. They dive into the challenges of reverse engineering CAN messages, designing a distributed architecture with Elixir processes, and ensuring safety with fail-safe modes and emergency shutoffs. Beyond the technical, the team discusses their motivation for the project—upgrading older vehicles with modern features to keep them on the road, building an open-source platform to share their findings with others, and above all-- to just have fun. They explore potential applications for OVCS in boats, construction equipment, and other vehicles, while reflecting on the hurdles of certifying the system for road use. If you’ve ever wondered how Elixir and Nerves can drive innovation beyond software, this episode is packed with insights into automotive computing, hardware development, and the collaborative potential of open-source projects. Topics Discussed in this Episode: Retrofitting a 2007 VW Polo with electric engines and modern tech Building an open-source Vehicle Control System (OVCS) using Elixir and Nerves Leveraging Elixir to interact with the CAN bus and parse proprietary messages Designing a Vehicle Management System (VMS) to coordinate vehicle components Developing custom hardware for CAN communication Creating a YAML-based DSL for CAN message and frame descriptions Building a distributed architecture using Elixir processes Ensuring safety with fail-safe modes and emergency shutoffs Using Flutter and Nerves to build a custom infotainment system Exploring autonomous driving features with a ROS2 bridge Developing remote control functionality with a Mavlink transmitter Testing OVCS features at scale with a Traxxas RC car (OVCS Mini) Challenges of certifying OVCS for road use and meeting regulatory requirements Encouraging community contributions to expand OVCS functionality Balancing open-source projects with contract work to sustain development The fun and fulfillment of experimenting with Elixir beyond traditional applications Links mentioned: https://www.spin42.com/ https://nerves-project.org/ Quadcopter https://github.com/Spin42/elicopter https://github.com/linux-can/can-utils https://docs.kernel.org/networking/can.html https://github.com/open-vehicle-control-system/cantastic https://github.com/commaai/opendbc https://en.wikipedia.org/wiki/CAN_bus#CAN_FD https://comma.ai/ https://en.wikipedia.org/wiki/CAN_FD https://webkit.org/wpe/ https://docs.nvidia.com/jetson/archives/r35.4.1/DeveloperGuide/text/SD/WindowingSystems/WestonWayland.html https://buildroot.org/ https://vuejs.org/ https://flutter.dev/ https://github.com/smartrent/elixir_flutter_embedder https://www.raspberrypi.com/products/raspberry-pi-5/ The Rabbit Pickup https://www.hemmings.com/stories/value-guide-1980-83-volkswagen-pickup https://www.expresslrs.org/software/mavlink https://industrial-training-master.readthedocs.io/en/melodic/_source/session7/ROS1-ROS2-bridge.html https://github.com/ros2/rcl https://github.com/open-vehicle-control-system/traxxas Contact Marc, Thibault, and Loïc: info@spin42.com Special Guests: Loïc Vigneron, Marc Lainez, and Thibault Poncelet.…

Elixir Wizards

1
Creating Horizon: Deploy Elixir Phoenix Apps on FreeBSD with Jim Freeze 44:48

32 weeks پیش44:48

44:48

The Elixir Wizards welcome Jim Freeze, organizer of ElixirConf and creator of the Horizon library. Jim shares his journey from organizing Ruby conferences to founding and growing ElixirConf into the community cornerstone it is today. He reflects on the challenges of running a major conference, how COVID-19 shaped the event, and why the talks remain an evergreen resource for the Elixir ecosystem. We discuss Horizon, Jim’s deployment library for Elixir and Phoenix applications with Postgres on FreeBSD. Driven by a need for simplicity and cost-effectiveness, Jim explains how Horizon minimizes external dependencies while delivering fault-tolerant and streamlined setups. He compares it to tools like Fly, Terraform, and Ansible, highlighting its low cognitive load and flexibility—key benefits for developers seeking more control over their deployment environments. Jim also unpacks the broader value of understanding and customizing your deployment stack rather than relying solely on managed services. He discusses the benefits of using FreeBSD, including its stability, security, and performance advantages, as well as its robust ZFS file system. Jim emphasizes the importance of coherent deployment workflows, community collaboration, and contributions to open-source projects like Horizon. He invites listeners to explore Horizon, share feedback, and own their deployments. Topics discussed in this episode: Jim Freeze’s background organizing RubyConf and founding ElixirConf Reducing reliance on managed services and external dependencies Simplifying deployments with minimal tools and lower cognitive overhead The trade-offs of cutting-edge tools vs. stable, well-documented solutions The importance of customizing deployment tools to meet specific needs Addressing challenges with Tailwind compatibility Streamlining the FreeBSD installation process for Horizon users Community collaboration: contributing to open-source tools Jim’s vision for Horizon: PKI support, hot standby features, and serverless potential Links mentioned Nine Minutes of Elixir https://www.youtube.com/@ElixirConf https://github.com/liveview-native https://github.com/elixir-nx/nx https://2024.elixirconf.com/ https://github.com/jfreeze/horizon https://hexdocs.pm/horizon/deploying-with-horizon.html#web-cluster-topology https://kamal-deploy.org/ https://fly.io/ https://aws.amazon.com/console/ https://www.digitalocean.com/ https://cloud.google.com/ https://www.cloudflare.com/ https://www.hetzner.com/ https://www.proxmox.com/en/ https://nginx.org/ https://github.com/openzfs/zfs Zettabyte File System https://en.wikipedia.org/wiki/ZFS https://www.postgresql.org/ https://www.terraform.io/ https://www.ansible.com/ https://docs.freebsd.org/ https://www.redhat.com/ https://ubuntu.com/ https://esbuild.github.io/ Listener's Survey: https://smr.tl/EWS13 Special Guest: Jim Freeze.…

Elixir Wizards

1
Telemetry & Observability for Elixir Apps at Cars.com with Zack Kayser & Ethan Gunderson 42:39

33 weeks پیش42:39

42:39

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. Topics Discussed: Cars.com’s transition to Elixir and scaling solutions The role of observability in large-scale systems Uncovering insights by asking unplanned system questions Managing high-traffic and concurrent users with Elixir Diagnosing incidents and preventing recurrence using telemetry Balancing data collection with storage constraints Sampling strategies for large data volumes Tracing and spans in observability LiveView’s influence on deployments and WebSocket behavior Mitigating downstream effects of socket reconnections Contextual debugging for system behavior insights Observability strategies for small vs. large-scale apps OpenTelemetry for vendor-agnostic instrumentation Leveraging OpenTelemetry contrib libraries for easy setup Elixir’s telemetry library as an ecosystem cornerstone Tracing as the first step in observability Differentiating observability from business analytics Profiling with OpenTelemetry Erlang project tools The value of profiling for performance insights Making observability tools accessible and impactful for developers Links Mentioned https://www.carscommerce.inc/ https://www.cars.com/ https://hexdocs.pm/telemetry/readme.html https://kubernetes.io/ https://github.com/ninenines/cowboy https://hexdocs.pm/bandit/Bandit.html https://hexdocs.pm/broadway/Broadway.html https://hexdocs.pm/oban/Oban.html https://www.dynatrace.com/ https://www.jaegertracing.io/ https://newrelic.com/ https://www.datadoghq.com/ https://www.honeycomb.io/ https://fly.io/phoenix-files/how-phoenix-liveview-form-auto-recovery-works/ https://www.elastic.co/ https://opentelemetry.io/ https://opentelemetry.io/docs/languages/erlang/ https://opentelemetry.io/docs/concepts/signals/traces/ https://opentelemetry.io/docs/specs/otel/logs/ https://github.com/runfinch/finch https://hexdocs.pm/telemetry_metrics/Telemetry.Metrics.html https://opentelemetry.io/blog/2024/state-profiling https://www.instrumentingelixir.com/ https://prometheus.io/ https://www.datadoghq.com/dg/monitor/ts/statsd/ https://x.com/kayserzl https://github.com/zkayser https://bsky.app/profile/ethangunderson.com https://github.com/open-telemetry/opentelemetry-collector-contrib Special Guests: Ethan Gunderson and Zack Kayser.…

Elixir Wizards

1
Scaling the Daylite Apple-Native CRM Using Elixir with AJ 52:21

34 weeks پیش52:21

52:21

AJ (Alykhan Jetha), CEO and CTO of Marketcircle, joins the Elixir Wizards to share his experience building and evolving Daylite, their award-winning CRM and business productivity app for Apple users. He details his experiences as a self-taught programmer and how Marketcircle has navigated pivots, challenges, and opportunities since its founding in 1999. AJ explains why they migrated Daylite’s backend to Elixir, focusing on their sync engine, which demands high concurrency and fault tolerance. He highlights how Elixir has improved performance, reduced cloud costs, and simplified development with its approachable syntax and productive workflows. The conversation also touches on the technical hurdles of deploying native apps for Apple devices and the potential for integrating new technologies like LiveView Native to streamline cross-platform development. For technical founders, AJ emphasizes the importance of leveraging your strengths (“superpowers”), staying deeply connected to the development process, and finding stability in tools like Elixir amidst a rapidly evolving tech ecosystem. He also shares Marketcircle’s roadmap for migrating more customers to Elixir-powered systems and explores the potential for new features in their native apps. Tune in for insights on building resilient systems, navigating technical and business challenges, and how Elixir is shaping Marketcircle’s future. Topics discussed in this episode: AJ’s journey as a self-taught programmer and entrepreneur Marketcircle’s evolution since 1999 and lessons from their pivots Daylite’s growth as a flagship product for Apple users Migrating to Elixir for high concurrency and fault tolerance How Elixir improved performance and reduced cloud costs The simplicity of Elixir and its impact on developer onboarding Challenges in managing a growing microservices architecture Insights into deploying native apps for the Apple ecosystem Exploring LiveView Native for future cross-platform development Advice for technical founders: leveraging your superpowers Staying connected to development to maintain system understanding The role of Elixir in improving development efficiency and stability Planning gradual customer migrations to an Elixir-powered backend Potential new features for Daylite’s native apps Benefits of collaboration with the Elixir community #ElixirMullet -- native app in the front, Elixir in the back Navigating a rapidly evolving tech ecosystem as a founder Leveraging Elixir to future-proof Marketcircle’s systems Balancing technical and business priorities in a startup environment AJ’s thoughts on the future of Elixir in powering business tools Links mentioned: https://www.marketcircle.com/ Daylite.app https://www.nextcomputers.org/ https://www.digitalocean.com/ Python Async https://docs.python.org/3/library/asyncio.html https://github.com/sinatra/sinatra https://github.com/dependabot https://kafka.apache.org/ https://www.djangoproject.com/ https://github.com/socketry/falcon https://github.com/puma/puma https://www.swift.org/blog/announcing-swift-6/ https://en.wikipedia.org/wiki/Async/await https://www.ffmpeg.org/ https://www.sqlite.org/ https://github.com/commanded/commanded https://pragprog.com/titles/khpes/real-world-event-sourcing/ https://en.wikipedia.org/wiki/Ship_of_Theseus https://reactnative.dev/ https://www.electronjs.org/ https://en.wikipedia.org/wiki/WebOS https://www.linkedin.com/in/alykhanjetha/ https://bsky.app/profile/ajetha.bsky.social Special Guest: Alykhan Jetha.…

Elixir Wizards

1
Creating the Castmagic AI-Powered Content Workflow Platform with Justin Tormey 35:40

35 weeks پیش35:40

35:40

Justin Tormey, co-founder of Castmagic, joins the Elixir Wizards to discuss building an AI-powered content creation app. Castmagic repurposes audio and video into social media posts, blog articles, newsletters, and more. The tech stack leverages OpenAI and Anthropic LLMs with Elixir as the coordination layer and Phoenix LiveView powering the front end. Justin dives into the technical details of Castmagic, including the integration of JavaScript libraries like ProseMirror and TipTap through LiveSvelte, as well as enabling real-time collaboration with CRDTs and YDoc. He shares the benefits and challenges of using Elixir for rapid development, as well as the trade-offs between custom code and off-the-shelf solutions. The conversation also covers Justin’s entrepreneurial journey, highlighting the advantages of bootstrapping over venture capital, the importance of acquiring early customers, and creative marketing strategies like affiliate programs and software marketplaces. Whether you're an Elixirist exploring machine learning or an aspiring tech founder, tune in to learn more about AI with Elixir, navigating startup challenges, and turning ideas into impactful software. Topics discussed in this episode: Building Castmagic to generate content from audio and video for creators Using AI services like OpenAI and Anthropic for transcription and workflows Elixir as the coordination layer for complex processes Rapid UI development with Phoenix LiveView Integrating rich text editing libraries through LiveSvelte Enabling collaborative editing with CRDTs and YDoc Balancing offline functionality with cloud-based AI tools Challenges of working with external AI services Exploring the future of multimodal AI in product development Bootstrapping vs. venture capital: benefits and challenges Strategies for finding distribution channels and early adopters Creative approaches to marketing, including affiliates and marketplaces Balancing engineering efforts with customer and business needs Practical advice for navigating the early stages of a startup Links mentioned: https://www.castmagic.io/ https://pragprog.com/titles/jaerlang2/programming-erlang-2nd-edition/ https://www.blockchain.com/ https://fly.io/ https://hexdocs.pm/live_svelte/readme.html https://github.com/woutdp/live_svelte https://prosemirror.net/ https://tiptap.dev/ https://docs.yjs.dev/api/y.doc https://hexdocs.pm/polymorphic_embed/readme.html https://github.com/elixir-nx/nx https://github.com/elixir-nx/tokenizers https://github.com/thmsmlr/instructor_ex https://openai.com/ https://www.anthropic.com/ https://getoban.pro/ https://github.com/wojtekmach/req https://ollama.com/ https://x.com/j_tormey Special Guest: Justin Tormey.…

Elixir Wizards

1
Creating the Standd AI-Native Due Diligence Platform with Stephen Solka 48:44

36 weeks پیش48:44

48:44

Stephen Solka, CTO and co-founder of Standd.io, joins Elixir Wizards Owen and Charles to share the journey of building an AI-native deal intelligence and due diligence platform. Designed to streamline document analysis and text generation for venture capital firms, Standd.io leverages large language models and AI tools to address key customer pain points in document workflows. Stephen explains how Elixir and Phoenix LiveView enabled rapid UI iteration and seamless integration between the front-end and back-end. The conversation also explores the human side of startup life. Stephen reflects on balancing tech debt with customer demands, the value of accelerators in building networks and securing funding, and the challenges of pricing in early-stage startups. He emphasizes the importance of validating ideas with potential customers and learning from the hurdles of growing a business. Tune in for insights on leveraging AI in Elixir, solving real-world problems, and navigating the journey from concept to company. Topics discussed in this episode: The journey from self-taught programmer to CTO The perks of Phoenix LiveView for rapid UI development Integrating front-end and back-end technologies AI tools for code generation How early adopters balance functionality with product polish Validating ideas and understanding customer needs The impact of accelerators on networking and fundraising Approaches to managing pricing strategies for startups Balancing technical debt with feature development The role of telemetry and error reporting in product development Creating collaborative and supportive tech communities Educating users on AI’s capabilities and limitations The broader implications of AI tools across industries Links Mentioned Contact Stephen & Julie at Standd: founders@standd.io https://www.standd.io/ https://www.digitalocean.com/community/tutorials/gangs-of-four-gof-design-patterns https://www.thriftbooks.com/w/code-complete_steve-mcconnell/248753/item/15057346/ https://aws.amazon.com/sagemaker/ https://www.anthropic.com/ https://getoban.pro/ https://kubernetes.io/ https://www.apollographql.com/ https://aws.amazon.com/startups/accelerators https://accelerate.techstars.com/ https://aider.chat/ https://github.com/Aider-AI/aider https://neovim.io/ https://ui.shadcn.com/ https://tailwindui.com/ https://www.ycombinator.com/ https://www.thriftbooks.com/w/close-to-the-machine-technophilia-and-its-discontents_ellen-ullman/392556 Special Guest: Stephen Solka.…

به Player FM خوش آمدید!

Player FM در سراسر وب را برای یافتن پادکست های با کیفیت اسکن می کند تا همین الان لذت ببرید. این بهترین برنامه ی پادکست است که در اندروید، آیفون و وب کار می کند. ثبت نام کنید تا اشتراک های شما در بین دستگاه های مختلف همگام سازی شود.