Podcasts about Functional programming

In this episode, Stewart Alsop sits down with Joe Wilkinson of Artisan Growth Strategies to talk through how vibe coding is changing who gets to build software, why functional programming and immutability may be better suited for AI-written code, and how tools like LLMs are reshaping learning, work, and curiosity itself. The conversation ranges from Joe's experience living in China and his perspective on Chinese AI labs like DeepSeek, Kimi, Minimax, and GLM, to mesh networks, Raspberry Pi–powered infrastructure, decentralization, and what sovereignty might mean in a world where intelligence is increasingly distributed. They also explore hallucinations, AlphaGo's Move 37, and why creative “wrongness” may be essential for real breakthroughs, along with the tension between centralized power and open access to advanced technology. You can find more about Joe's work at https://artisangrowthstrategies.com and follow him on X at https://x.com/artisangrowth.Check out this GPT we trained on the conversationTimestamps00:00 – Vibe coding as a new learning unlock, China experience, information overload, and AI-powered ingestion systems05:00 – Learning to code late, Exercism, syntax friction, AI as a real-time coding partner10:00 – Functional programming, Elixir, immutability, and why AI struggles with mutable state15:00 – Coding metaphors, “spooky action at a distance,” and making software AI-readable20:00 – Raspberry Pi, personal servers, mesh networks, and peer-to-peer infrastructure25:00 – Curiosity as activation energy, tech literacy gaps, and AI-enabled problem solving30:00 – Knowledge work superpowers, decentralization, and small groups reshaping systems35:00 – Open source vs open weights, Chinese AI labs, data ingestion, and competitive dynamics40:00 – Power, safety, and why broad access to AI beats centralized control45:00 – Hallucinations, AlphaGo's Move 37, creativity, and logical consistency in AI50:00 – Provenance, epistemology, ontologies, and risks of closed-loop science55:00 – Centralization vs decentralization, sovereign countries, and post-global-order shifts01:00:00 – U.S.–China dynamics, war skepticism, pragmatism, and cautious optimism about the futureKey InsightsVibe coding fundamentally lowers the barrier to entry for technical creation by shifting the focus from syntax mastery to intent, structure, and iteration. Instead of learning code the traditional way and hitting constant friction, AI lets people learn by doing, correcting mistakes in real time, and gradually building mental models of how systems work, which changes who gets to participate in software creation.Functional programming and immutability may be better aligned with AI-written code than object-oriented paradigms because they reduce hidden state and unintended side effects. By making data flows explicit and preventing “spooky action at a distance,” immutable systems are easier for both humans and AI to reason about, debug, and extend, especially as code becomes increasingly machine-authored.AI is compressing the entire learning stack, from software to physical reality, enabling people to move fluidly between abstract knowledge and hands-on problem solving. Whether fixing hardware, setting up servers, or understanding networks, the combination of curiosity and AI assistance turns complex systems into navigable terrain rather than expert-only domains.Decentralized infrastructure like mesh networks and personal servers becomes viable when cognitive overhead drops. What once required extreme dedication or specialist knowledge can now be done by small groups, meaning that relatively few motivated individuals can meaningfully change communication, resilience, and local autonomy without waiting for institutions to act.Chinese AI labs are likely underestimated because they operate with different constraints, incentives, and cultural inputs. Their openness to alternative training methods, massive data ingestion, and open-weight strategies creates competitive pressure that limits monopolistic control by Western labs and gives users real leverage through choice.Hallucinations and “mistakes” are not purely failures but potential sources of creative breakthroughs, similar to AlphaGo's Move 37. If AI systems are overly constrained to consensus truth or authority-approved outputs, they risk losing the capacity for novel insight, suggesting that future progress depends on balancing correctness with exploratory freedom.The next phase of decentralization may begin with sovereign countries before sovereign individuals, as AI enables smaller nations to reason from first principles in areas like medicine, regulation, and science. Rather than a collapse into chaos, this points toward a more pluralistic world where power, knowledge, and decision-making are distributed across many competing systems instead of centralized authorities.

In this episode of Beam Radio, Lars and Andrew welcome Peter Saxton, a key figure in the Gleam programming language community. They discuss Peter's journey into the BEAM ecosystem, the philosophy and features of Gleam, and how it compares to other languages like Elm. Check out the Gleam Gatherining - 21 February 2026 - Bristol, UK https://gleamgathering.com/ Check out Gleam https://gleam.run/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

This interview was recorded for GOTO Unscripted.https://gotopia.techSimon Peyton Jones - Key Contributor of Haskell & Engineering Fellow at Epic GamesChelsea Troy - MLOps Tech Lead at Mozilla & Lecturer at University of ChicagoRESOURCESSimonhttps://simon.peytonjones.orghttps://en.wikipedia.org/wiki/Simon_Peyton_Joneshttps://www.linkedin.com/in/simonpjChelseahttps://chelseatroy.comhttps://social.clawhammer.net/@HeyChelseaTroyhttps://www.linkedin.com/in/chelseatroyLinkshttps://www.barefootcomputing.orghttps://www.computingatschool.org.uk/resources/2015/januaryhttps://www.computingatschool.org.uk/forum-news-blogs/2023/novemberhttps://chelseatroy.com/2025/05/14https://computingeducation.org.ukhttps://www.raspberrypi.org/blogDESCRIPTIONSimon discusses how a simple math problem led him to discover the binary system 55 years ago. He explores how to maintain the essence of computational thinking in an era where AI can instantly solve coding problems, emphasizing concrete, motivated contexts over abstract algorithms.The discussion spans from elementary programming to his unique role as a computing fellow at Epic Games, where he works with CEO Tim Sweeney to design the Verse programming language, proving that even big companies can prioritize denotational semantics over quarterly profits.RECOMMENDED BOOKSSimon Peyton Jones • The Implementation of Functional Programming Languages • https://amzn.to/3HQE0XnChelsea Troy • Remote Work Sucks • https://heychelsePsst! The Folium Diary has something it wants to tell you - please come a little closer...YOU can change the world - you do it every day. Let's change it for the better, together.Listen on: Apple Podcasts SpotifyBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

This interview was recorded at GOTO Copenhagen 2024.https://gotocph.comRuss Olsen - Author of "Getting Clojure" & "Eloquent Ruby"James Lewis - Software Architect & Director at ThoughtworksRESOURCESRusshttps://bsky.app/profile/russolsen.bsky.socialhttps://hachyderm.io/@russolsenhttps://github.com/russolsenhttps://www.linkedin.com/in/russolsenhttp://russolsen.comJameshttps://bsky.app/profile/boicy.bovon.orghttps://linkedin.com/in/james-lewis-microserviceshttps://github.com/boicyhttps://www.bovon.orgRead the full abstract here:https://gotocph.com/2024/sessions/3522RECOMMENDED BOOKSRuss Olsen • Getting Clojure • https://amzn.to/3J8zI8sRuss Olsen • Eloquent Ruby • https://amzn.to/37gOhcGRuss Olsen • Design Patterns in Ruby • https://amzn.to/3r2uBjWBarry O'Reilly • Unlearn • https://amzn.to/3O3DQeIJez Humble, Joanne Molesky & Barry O'Reilly • Lean Enterprise • https://amzn.to/3Cpt6ETSarah Wells • Enabling Microservice Success • https://amzn.to/4aa8xrvMartin Fowler • Refactoring • https://amzn.to/3EVcHXQMatthew Skelton & Manuel Pais • Team Topologies • http://amzn.to/3sVLyLQInspiring Tech Leaders - The Technology PodcastInterviews with Tech Leaders and insights on the latest emerging technology trends.Listen on: Apple Podcasts SpotifyBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

פרק מספר 504 של רברס עם פלטפורמה, שהוקלט ב-11 בנובמבר 2025 - פרק ראשון אחרי כנס Reversim 2025, שהיה מוצלח מאוד (גם בסטנדרטים הגבוהים ממילא). בזמן הקלטת הפרק עדיין לא פורסמו ההקלטות, אבל עכשיו כבר כן - Reversim Summit 2025 - YouTube - שווה לפנות כמה שעות טובות. בינתיים, ואורי ורן (וניק!) מארחים את דניאל בסקין כדי לדבר על תכנות פונקציונלי.

This episode of Beam Radio features a conversation between Lars Wikman and Michał Buszkiewicz, discussing the adoption and impact of the Elixir programming language. They explore the Elixir Hub initiative, Elixir survey results, and the language's role in the tech community. Take the Survey: https://elixir-survey.typeform.com/2025-edition Curiosum: https://www.curiosum.com/ Elixir Hub: https://elixir-hub.com/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

Mike Sperber is the CEO of Active Group, a company designed for Counseling, Development and Training in functional programming. He is a co-organizer of Bob Konf and FunArch, the Co-founder of the leading german blog on functional programming. Member of the Editorial Board of the JFP. Part of the R6RS, the 6th revised report on the Algorithmic Language Scheme. In our conversation we talk about C, Lisp, Emacs Lisp, Scheme and his involvement with the R6RS. His views on mathematics and formal methods as languages, his views on the use of Functional Programming in the Industry, his thoughts of how Object Oriented Programming is dead. Macros, hygienic macros and much more! We also talk about BobKonf and FunArch as amazing confereces on Functional Programming and their design and archtechture. BobKonf currently has a call for talks open and goes until november 17th. Consider supporting the show! TTFA Patreon One time donations Merch Store Links Mike's Website Bob Konf FunArch Functional Programming Blog TTFA Graduate Mentorship

Erik Stenman joins the BeamRadio pod to discuss The BEAM Book (you can read it for free!). Erik started programming in 1980 and has a rich history in tech and shares his journey with the BEAM. Follow Erik: @erikstenman and @HappiHacking on X.com https://www.happihacking.com/ https://stenmans.org/happiblog/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

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/nloRcgngTk?si=g4Zd4N1s56Ronrtw https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html https://wordpress.com/ https://elixir-lang.org/ S14E01 Zigler: Zig NIFs for Elixir https://youtu.be/hSAvWxh26TU?si=d55tVuZbNw0KCfT https://ziglang.org/ https://hexdocs.pm/zigler/Zig.html https://github.com/blue-heron/blueheron 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=Ux2lebiwEp3mc0e 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

In this episode Mike Hostetler shares his journey into the Elixir ecosystem and the development of Jido, the Elixir autonomous agent framework. Find Mike: https://mike-hostetler.com/ and https://x.com/mikehostetler Learn more about Jido: https://agentjido.xyz/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this episode, Lars, Andrew, and Chris discuss various aspects of Elixir development, including the journey of transitioning to Elixir (you'll never guess), the aesthetics of programming languages, and the importance of community engagement through meetups. Keep up with Chris! Twitter: @superchris https://www.linkedin.com/in/chris-nelson-038875/ https://launchscout.com/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this episode of BeamRadio, hosts Andrew Ek and Alex Koutmos are joined by German Velasco. They chat about the complexities and advantages of using Elixir and Phoenix for software development and explore the onboarding process for developers transitioning from other languages. Get in touch with German: Bluesky: ‪@germsvel.com‬ Twitter: @germsvel https://www.germanvelasco.com/ https://www.elixirstreams.com/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubRead the full transcription of the interview hereMarcin Moskala - Fullstack Kotlin Developer, Founder of Kt. Academy & Author of "Effective Kotlin", et al.Nicola Corti - Staff Android Engineer at Meta, React Native Core Team Member & Open Source LoverRESOURCESMarcinhttps://x.com/marcinmoskalahttps://kt.academyhttps://github.com//marcinmoskalahttps://www.instagram.com/cortinicoNicolahttps://x.com/cortinicohttps://ncorti.comhttps://github.com/cortinicohttps://www.linkedin.com/in/cortinicoLinkshttps://developer.android.com/develop/ui/compose/kotlinhttps://detekt.devhttps://www.abreslav.comhttps://kt.academy/article/ek-compositionhttps://kt.academy/article/books-kotlin-for-developers-readyDESCRIPTIONIn this episode of the "GOTO Book Club", Nicola Corti talks to Marcin Moskala, author of "Effective Kotlin", to unravel the inspiration, evolution, and community impact of his work.Moskala reflects on his decade-long journey with Kotlin, revealing how his book bridges the gap between Java-centric practices and Kotlin's idiomatic potential. The discussion spans essential topics like factory functions, composition over inheritance, and the iterative process behind curating best practices tailored to Kotlin's strengths.Marcin also highlights the "Kotlin for Developers" series and his Give IT Forward initiative, showcasing his commitment to empowering developers and fostering accessible programming education worldwide.RECOMMENDED BOOKSMarcin Moskala • Effective KotlinMarcin Moskala • Kotlin EssentialsMarcin Moskala • Functional KotlinMarcin Moskala • Kotlin CoroutinesMarcin Moskala • Advanced KotlinMarcin Moskala & Igor Wojda • Android Development with KotlinVenkat Subramaniam • Programming KotlinBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

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.

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/BluetoothLowEnergy 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/Hostcontrollerinterface Circuits UART Library https://hexdocs.pm/circuitsuart/readme.html SPI (Serial Peripheral Interface) https://github.com/elixir-circuits/circuitsspi 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/ectosqlite3 https://github.com/nerves-livebook/nerveslivebook Special Guest: Connor Rigby.

In this episode of Beam Radio, Andrew Ek and Bruce Tate welcome Zach Daniel to discuss his journey with Elixir, the impact of the Ash framework, and the introduction of Igniter, a code generation and patching tool. We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

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/theelixirast/ 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/Singleinstruction,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

In this episode, Conor and Ben chat about algorithms / combinators in C++26 Senders and Receivers.Link to Episode 235 on WebsiteDiscuss this episode, leave a comment, or ask a question (on GitHub)SocialsADSP: The Podcast: TwitterConor Hoekstra: Twitter | BlueSky | MastodonBen Deane: Twitter | BlueSkyShow NotesDate Generated: 2025-05-13Date Released: 2025-05-23C++26 Senders and ReceiversThe Evolution of Functional Programming in C++ - Abel Sen - C++Online 2024C++23 std::flat_mapCppNorth 2023: Composition Intuition - Conor HoekstraC++Now 2023: Applicative: the Forgotten Functional Pattern - Ben DeaneC++Now 2019: Ben Deane “Identifying Monoids: Exploiting Compositional Structure in Code”C++ std::optional::and_thenHaskell joinIntro Song InfoMiss You by Sarah Jansen https://soundcloud.com/sarahjansenmusicCreative Commons — Attribution 3.0 Unported — CC BY 3.0Free Download / Stream: http://bit.ly/l-miss-youMusic promoted by Audio Library https://youtu.be/iYYxnasvfx8

Andy is convinced that functional programming isn't boring. Listen to find out if he's right!   Functional Programming & Haskell Beautiful Racket Functional Programming & Haskell – Computerphile         Support us on Patreon and get an ad-free RSS feed with early episodes sometimes   See our contact page for ways to get... Read More

Andy is convinced that functional programming isn't boring. Listen to find out if he's right!   Functional Programming & Haskell Beautiful Racket Functional Programming & Haskell – Computerphile         Support us on Patreon and get an ad-free RSS feed with early episodes sometimes   See our contact page for ways to get... Read More

Jemima Abu, Senior Product Engineer at CAIS, joins the podcast to unpack her no-fluff approach to functional programming in JavaScript. From why predictable code matters to how higher-order functions like map and reduce can save your sanity, Jemima breaks down real-world lessons on purity, immutability, and when it's okay to not be a functional purist. Links https://v3.jemimaabu.com https://www.jemimaabu.com https://www.linkedin.com/in/jemimaabu https://x.com/jemimaabu https://github.com/jemimaabu We want to hear from you! How did you find us? Did you see us on Twitter? In a newsletter? Or maybe we were recommended by a friend? Let us know by sending an email to our producer, Emily, at emily.kochanekketner@logrocket.com (mailto:emily.kochanekketner@logrocket.com), or tweet at us at PodRocketPod (https://twitter.com/PodRocketpod). Follow us. Get free stickers. Follow us on Apple Podcasts, fill out this form (https://podrocket.logrocket.com/get-podrocket-stickers), and we'll send you free PodRocket stickers! What does LogRocket do? LogRocket provides AI-first session replay and analytics that surfaces the UX and technical issues impacting user experiences. Start understand where your users are struggling by trying it for free at [LogRocket.com]. Try LogRocket for free today.(https://logrocket.com/signup/?pdr) Special Guest: Jemima Abu.

A fabulous converstation with Davide Bettio and Paul Guyot about AtomVM - the Erlang virtual machine for IoT devices. https://www.atomvm.net/ https://github.com/bettio https://github.com/pguyot We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Twitter: @akoutmos @ektastrophe @meryldakin Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this episode of Beam Radio, hosts Andrew Ek and Lars Wikman welcome Josh Price from Alembic. They discuss the recent AlchemyConf, the value of smaller conferences, and the importance of community in the Elixir ecosystem. Josh shares insights on how Ash simplifies the process of building applications, integrates with AI, and future-proofs projects. We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

NX provides a powerful framework for machine learning in Elixir and Lars, Andrew and Paulo Valente take a deep dive into it! Connect with Paulo on Bluesky - @polvalente.social Come join us! GigCityElixir and NervesConf US - May 8-10, Chattanooga, TN GigCityElixir.com (https://www.gigcityelixir.com/) Goatmire Elixir and NervesConf - Sept 10-12, Varburg, Sweden Goatmire.com (https://goatmire.com/) We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this conversation, Lars and Chris delve into the intersection of Elixir, data engineering, and data science. They explore the significance of data pipelines, the role of Elixir in transforming data, and the challenges faced in data processing. Find Chris on Bluesky (@cigrainger.bsky.social) and on the Elixir Forum. Keep up to date with our hosts: Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

Jak and Lars have a delightful conversation about Gleam, the language's type safety, adoption and ecosystem growth. Find Jak: giacomocavalieri.me (giacomocavalieri.me) @giacomo_cava (https://x.com/giacomo_cava) We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this conversation, Bruce, Andrew, and James discuss their experiences with Elixir programming, the importance of exploring and modeling in software development, and innovative educational approaches using Livebook. James E. Gray II @JEG2@genserver.social https://www.linkedin.com/in/james-edward-gray-ii/ Upcoming Conferences: https://codebeamamerica.com/ https://www.gigcityelixir.com/ https://goatmire.com/ Designing Elixir Systems with OTP (Gray/Tate) https://www.pragprog.com/titles/jgotp/designing-elixir-systems-with-otp/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

The panel chats about making Elixir easy to learn for devs from other languages and how to talk about Elixir in the greater development community. This the episode to share with all your friends that need to learn Elixir and companies that should be using it. https://peterullrich.com/ https://bsky.app/profile/peterullrich.com We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

David MacQueen has worked at Bell Labs for around 20 years during it's Golden Age. Professor at Chicago University for 23 years. He is one of the designers of SML, one of the fathers of HOPE the programming language that introduced the notion of Algebraic Datatypes. So this interview was very special to me personally where I could get to hear all the stories about the dawn of Functional Programming as we know. And it is my great pleasure to have the honor to share it with you all. Links David's Website David's Github Luca Cardelli and the Early Evolution of ML The History of SML HOPE SML Website SML/NJ Website SML/NJ Github SML Family Website

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/CANbus#CANFD https://comma.ai/ https://en.wikipedia.org/wiki/CANFD 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/elixirflutterembedder 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.

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://youtu.be/hht9s6nAAx8?si=ocrk1wQtGplSGL0B) 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.

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.

How it started and how it's going - an enlightening chat with Björn Gustavsson about Erlang/Elixir history. Read the Erlang/OTP blog (https://www.erlang.org/blog) We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

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

Lars talks with Brian Underwood about EctoWatch, his library. "EctoWatch allows you to easily get notifications about database changes directly from PostgreSQL." Find more from Brian at Brian-underwood.codes (Brian-underwood.codes) We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts: Twitter: @akoutmos @ektastrophe @meryldakin @redrapids Bluesky @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids.bskysocial Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this conversation, Lars, Zach, and Rebecca discuss the Ash framework and their upcoming book. They also touch on the Igniter tool. The book, titled 'Building Web Applications with Ash', will provide a comprehensive tutorial and reference for using Ash and is expected in beta by the end of the year with @pragprog We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Bluesky! @akoutmos.bsky.social @ektastrophe.bsky.social @lawik.bsky.social @RedRapids@bsky.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

Today on Elixir Wizards, indie developer Lucas Sifoni shares his experience prototyping a remote-controlled terrestrial telescope using Elixir, Nerves, Rust, and various hardware components. Lucas explains the basic components of a telescope, the challenges he faced during the development process, and the benefits of using Elixir and Nerves for hardware projects. Lucas emphasizes the importance of simulating hardware components and testing assumptions before working with physical devices, as well as the value of literate programming and executable blog posts for documenting and sharing the process. Lucas encourages listeners to explore Nerves and build their own hardware projects. He also gives a shout-out to the Nerves core team for their incredible work. Topics discussed in this episode: Challenges in optimizing wiring and PCB design for the prototype Benefits of Elixir and Nerves for hardware projects Communicating with Arduinos using serial connections and pattern matching Leveraging binary pattern matching and construction in Elixir for hardware Balancing educational value and real-world usability Learning CID software and parametric design for 3D printing components Growing interest in Nerves and hardware projects within the Elixir community Simulating hardware components and testing assumptions before physical implementation Literate programming and executable blog posts for documenting hardware projects Using Elixir's interoperability with Rust for performance-critical tasks Elixir's low fragmentation and high-quality libraries for various domains Potential for using Livebook in hardware projects, with some limitations Encouraging listeners to explore Nerves and build their own hardware projects Links mentioned https://lucassifoni.info/ https://www.rust-lang.org/ https://go.dev/ https://lisp-lang.org/ https://ubuntu.com/ https://hexdocs.pm/iex/IEx.html https://nerves-project.org/ https://lucassifoni.info/blog/prototyping-elixir-telescope-code-beam/ https://github.com/Lucassifoni/oiseaux https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html https://www.raspberrypi.com/ https://mangopi.org/ https://store.arduino.cc/products/arduino-nano https://elixir-circuits.github.io/ https://www.erlang.org/doc/apps/runtimetools/scheduler.html Binary pattern matching in Elixir with PNG parsing example https://zohaib.me/binary-pattern-matching-in-elixir/ Lucas' Code Beam Talk: https://www.youtube.com/watch?v=q7bleFzA11c https://github.com/membraneframework-labs https://github.com/talklittle/ffmpex https://studio.blender.org/training/3d-printing/ https://www.autodesk.com/products/fusion-360/personal https://en.wikipedia.org/wiki/Parametricdesign https://www.exem.fr/ https://www.kikk.be/exhibitions/collectif-lab212-nicolas-guichard-beatrice-lartigue/ https://livebook.dev/ https://github.com/elixir-nx/bumblebee https://github.com/rusterlium/rustlerhttps://www.youtube.com/watch?v=q7bleFzA11c Special Guest: Lucas Sifoni.

Today in the Creator's Lab, Tony Dang joins Elixir Wizards Sundi Myint and Owen Bickford to break down his journey of creating a local-first, offline-ready to-do app using Phoenix LiveView, Svelte, and CRDTs (Conflict-free Replicated Data Types). Tony explains why offline functionality matters and how this feature can transform various apps. He shares insights on different libraries, algorithms, and techniques for building local-first experiences and highlights the advantages of Elixir and Phoenix LiveView. Tony also shares his go-to tools, like Inertia.js for connecting Phoenix backends with JavaScript frontends, and favorite Elixir packages like Oban, Joken, and Hammer, offering a toolkit for anyone building powerful, adaptable applications. Topics discussed in this episode: Tony Dang's background from mechanical engineer to web developer Building an offline-enabled to-do app with Phoenix LiveView and Svelte CRDTs: Conflict-free Replicated Data Types for merging changes offline How to make a LiveView app work offline Sending full state updates vs. incremental updates for performance optimization Inspiring others through open-source projects and community contributions Learning vanilla Phoenix and Channels to understand LiveView better Handling stale CSRF tokens when reconnecting to a LiveView app offline Exploring service workers and browser APIs for managing offline connectivity Balancing the use of JavaScript and Elixir in web development Fostering a supportive and inspiring Elixir community Links mentioned: Working in Elevators: How to build an offline-enabled, real-time todo app (https://www.youtube.com/watch?v=PX9-lq0LL9Q) w/ LiveView, Svelte, & Yjs Tony's Twitter: https://x.com/tonydangblog https://liveview-svelte-pwa.fly.dev/ https://github.com/tonydangblog/liveview-svelte-pwa CRDT: https://en.wikipedia.org/wiki/Conflict-freereplicateddatatype PWA: https://en.wikipedia.org/wiki/Progressivewebapp https://github.com/josevalim/sync https://github.com/sveltejs/svelte https://github.com/woutdp/livesvelte https://github.com/yjs/yjs https://github.com/satoren/yex https://github.com/y-crdt/y-crdt https://linear.app/ https://github.com/automerge/automerge https://hexdocs.pm/phoenix/1.4.0-rc.1/presence.html Vaxine, the Rich CRDT Database for ElixirPhoenix Apps (https://www.youtube.com/watch?v=n2c5eWIfziY) | James Arthur | Code BEAM America 2022 https://github.com/electric-sql/vaxine Hybrid Logical Clocks https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html https://en.wikipedia.org/wiki/256(number) CSRF Tokens in LiveView https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html#getconnectparams/1 https://hexdocs.pm/phoenix/channels.html Authentication with Passkeys (https://www.youtube.com/playlist?list=PL8lFmBcH3vX-JNIgxW3THUy7REthSRFEI) Talk by Tony https://www.meetup.com/dc-elixir/ https://github.com/rails/rails https://github.com/facebook/react-native https://github.com/vuejs https://github.com/laravel/laravel https://hexdocs.pm/phoenixliveview/js-interop.html https://github.com/inertiajs https://github.com/inertiajs/inertia-phoenix https://savvycal.com/ https://github.com/wojtekmach/req https://github.com/oban-bg/oban https://github.com/joken-elixir/joken https://github.com/ExHammer/hammer Special Guest: Tony Dang.

Today on Elixir Wizards, Bryan Green shares how he transformed a vintage 1930s rotary phone into a fully functional cell phone using Elixir, Nerves, and a mix of hardware components. Bryan shares the highs and lows of his project, from decoding rotary dial clicks to troubleshooting hardware issues with LED outputs. He explains why Nerves was the perfect fit for this project, offering SSH access, over-the-air updates, and remote debugging. You'll also hear how Elixir's concurrency model helped him manage hardware inputs and outputs efficiently using GenStateMachine and Genservers. Elixir and Nerves really shine when modeling real-world systems. Bryan dives into how he used a finite state machine to track the phone's states and handled inputs from the rotary dial and hook switch via GPIO. For hardware enthusiasts, Bryan's advice is to embrace this “golden age” of DIY electronics. Whether you're experienced with embedded systems or just curious on where to start, Bryan's VintageCell can inspire you to tinker with a hardware engineering project. Key topics discussed in this episode: Advantages of functional programming and immutability in Elixir Building hardware projects using Adafruit components Why Nerves was the best choice for the VintageCell project Interpreting rotary dial clicks using GPIO and circuits.gpio Troubleshooting hardware issues with LED diagnostics Challenges in optimizing wiring and PCB design Benefits of Nerves: SSH access, OTA updates, and remote debugging Modeling real-world systems with Elixir and Nerves Implementing a finite state machine with GenStateMachine Managing input with Genservers for rotary dial and hook switch Leveraging community resources like Discord, Elixir Slack, and forums Practical advice for keeping hardware projects on track Potential applications from SMS servers to home automation Links mentioned: Vintage Cellphone: Bridging the Past and Future with Elixir (https://www.youtube.com/watch?v=U4hetzVpjmo) Seven Languages in Seven Weeks https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/ Seven More Languages https://pragprog.com/titles/7lang/seven-more-languages-in-seven-weeks/ Node.js https://github.com/nodejs https://nerves-project.org/ https://www.arduino.cc/ Adafruit Circuit Playground https://www.adafruit.com/category/965 Adafruit 3D Printed Star Trek Communicator https://learn.adafruit.com/3d-printed-star-trek-communicator Adafruit FONA 3G Cellular + GPS Breakout https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview https://github.com/elixir-circuits/circuitsgpio Nerves SSH https://hex.pm/packages/nervesssh OTA (over-the-air) Updates with NervesHub https://www.nerves-hub.org/ https://github.com/kicad Waveshare 4G Hat for Raspberry Pi https://www.waveshare.com/sim7600e-h-4g-hat.htm https://hexdocs.pm/genstatemachine/GenStateMachine.html https://hexdocs.pm/elixir/GenServer.html https://www.sparkfun.com/ https://www.digikey.com/ USB-C Gadget Mode with Nerves https://github.com/nerves-project/nervessystemrpi4/issues/18 https://livebook.dev/ https://codestorm.me/ https://github.com/codestorm1/vintage_cell/ Special Guest: Bryan Green.

This week we take a look at Bevy, a new game engine written in Rust. And in particular, we look at a core component of Bevy that has something to teach you even if you never write a game: its Entity Component System, or ECS. An ECS is an approach to managing complex systems with large numbers of moving parts, that takes some inspiration from the Relational Database world, and a little from Functional Programming to build something entirely unique and surprisingly high-performance.Joining us to explain all is Alice Cecile. She's part of the Bevy foundation, which is charting a course from data-management and rendering tool to fully-featured game development environment. A journey they've made huge progress on, but still expect to take another decade to come to full fruition. We look at the core ECS, and the wider project-management approaches they need to make the journey.–Support Developer Voices on Patreon: https://patreon.com/DeveloperVoicesSupport Developer Voices on YouTube: https://www.youtube.com/@developervoices/joinBevy: https://bevyengine.org/Bevy Examples: https://bevyengine.org/examples/Flecs (C++): https://github.com/SanderMertens/flecsTiny Glade (game): https://store.steampowered.com/app/2198150/Tiny_Glade/Alice on Mastodon: https://mastodon.gamedev.place/@alice_i_cecileKris on Mastodon: http://mastodon.social/@krisajenkinsKris on LinkedIn: https://www.linkedin.com/in/krisjenkins/Kris on Twitter: https://twitter.com/krisajenkins

To kick off Elixir Wizards Season 13, The Creator's Lab, we're joined by Zach Daniel, the creator of Igniter and the Ash framework. Zach joins hosts Owen Bickford and Charles Suggs to discuss the mechanics and aspirations of his latest brainchild, Igniter—a code generation and project patching framework designed to revolutionize the Elixir development experience. Igniter isn't just about generating code; it's about generating smarter code. By leveraging tools like Sourcerer and Rewrite, Igniter allows developers to modify source code and batch updates by directly interacting with Elixir's AST instead of regex patching. This approach streamlines new project setup and package installations and enhances overall workflow. They also discuss the strategic implications of Igniter for the broader Elixir community. Zach hopes Igniter will foster a more interconnected and efficient ecosystem that attracts new developers to Elixir and caters to the evolving needs of seasoned Elixir engineers. Topics discussed in this episode: Advanced package installation and code generation improve the developer experience Scripting and staging techniques streamline project updates Innovative methods for smoother installation processes in Elixir packages High-level tools apply direct patches to source code Progressive feature additions simplify the mix phx.new experience Chaining installers and composing tasks for more efficient project setup Continuous improvement in developer experiences to boost Elixir adoption Encourage listeners to collaborate by sharing code generation patterns Introduction of a new mix task aimed at removing the "unless" keyword in preparation for Elixir 1.18 You can learn more in the upcoming book "Building Web Applications with Ash Framework" by Zach and Rebecca Links mentioned: https://smartlogic.io/ https://alembic.com.au/blog/igniter-rethinking-code-generation-with-project-patching https://hexdocs.pm/igniter/readme.html https://github.com/ash-project/igniter https://www.zachdaniel.dev/p/serialization-is-the-secret https://www.zachdaniel.dev/p/welcome-to-my-substack https://ash-hq.org/ https://hexdocs.pm/sourceror/readme.html https://smartlogic.io/podcast/elixir-wizards/s10-e09-hugo-lucas-future-of-elixir-community/ https://github.com/hrzndhrn/rewrite https://github.com/zachdaniel https://github.com/liveshowy/webauthn_components https://hexdocs.pm/elixir/Regex.html https://github.com/msaraiva/vscode-surface https://github.com/swoosh/swoosh https://github.com/erlef/oidcc https://alembic.com.au/ https://www.zachdaniel.dev/ Special Guest: Zach Daniel.

The panel explores Poka Yoke with Bryan Hunter - the concept of mistake-proofing and its application in Erlang and Elixir. Bryan Hunter [GigCityElixir24] Poka Yoke, STAMP and the BEAM (https://youtu.be/0-aJwz6oPow?si=5hTL8HwHiJfYQb4S) Engineering A Safer World (https://a.co/d/1iQdN70) by Nancy G. Leveson We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Twitter @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

What is a program? Your answer to this question will determine the paradigm through which you view programming. During this episode, you'll come to understand how things change once you develop an awareness of your paradigm, and what. To kick off this episode, Stephanie shares key insights she took from Planet Argon's 2024 Ruby on Rails survey and dives deeper into her history with Ruby on Rails. Next, we dive into the definition of a paradigm and unpack three different paradigms you might hold as a developer: procedural, object-oriented, and functional. Considering how each of these impacts the way that you might approach your work as a developer, and what you can learn from the ones that are less familiar to you. Joël describes his scripting style and evaluates the concept of pure functions and their place in development, and we close by digging deeper into how your paradigm might impact the code that you write. Tune in to hear all this and more. Key Points From This Episode: The EPI feature that Joël has started to build out for his client. Why Stephanie is excited about the results of Planet Argon's 2024 Ruby on Rails community survey. What a procedural program is: programming envisions a program as a series of instructions to a computer. Defining an object-oriented paradigm: programming envisions a program as the behavior that emerges from objects talking to each other. How a functional paradigm envisions a program as a series of data transformations. Alan Turing and Alonzo Church's approach to understanding this. How a lot of the foundations of computer science came to be built before we had computers. Using Ruby to make judgments and assessing whether or not this is a procedural habit. Why Joël describes his scripting style as being very procedural. Unpacking the meaning of functional programming. Evaluating the concept of pure functions. Considering how your paradigm may impact the Ruby code that you write. Links Mentioned in Today's Episode: 2024 Ruby on Rails Community Survey (https://railsdeveloper.com/survey/2024/) Church-Turing Thesis (https://ocw.mit.edu/courses/24-242-logic-ii-spring-2004/489f7e42fb619645158d7c21a8fb83ad_chuh_trng_thesis.pdf) Dynamic type systems are not inherently more open (https://lexi-lambda.github.io/blog/2020/01/19/no-dynamic-type-systems-are-not-inherently-more-open/) What is Functional Programming? (blog.jenkster.com/2015/12/what-is-functional-programming.html) Blocks as an abstraction vs for loops (https://thoughtbot.com/blog/special-cases) Functional core imperative shell (https://www.destroyallsoftware.com/screencasts/catalog/functional-core-imperative-shell) Testing objects with a functional mindset
 (https://thoughtbot.com/blog/functional-viewpoints-on-testing-objectoriented-code) The Bike Shed (https://bikeshed.thoughtbot.com/) Joël Quenneville on LinkedIn (https://www.linkedin.com/in/joel-quenneville-96b18b58/) Support The Bike Shed (https://github.com/sponsors/thoughtbot)

Lars and Bruce have a fabulous chat with Marcel Fahle creator of Bold Video and Pidro, a classic multiplayer card game for iOS and Android. on X: @marcelfahle https://marcelfahle.net/ bold.video (https://bold.video/) Pidro card game (https://www.pidro.online/) We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Twitter @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

On this episode of Crazy Wisdom, I, Stewart Alsop, sit down with Ben Ford and Michael Greenberg for a dynamic conversation. Ben is the founder of Mission Control Dev, and Michael is the founder of Third Brain, a company focused on automating business operations. We explore a variety of topics, including the real meaning of "artificial intelligence," how AI is impacting various industries, and whether we truly have AI today. Michael introduces his concept of "Third Brain," a digital layer of operations, while Ben reflects on his military background and how it shapes his current work. Both offer unique perspectives on where technology is headed, especially around the future of knowledge work, digital transformation, and the human element in an increasingly automated world. Check out the links to learn more about Ben's Mission Control Dev and Michael's Third Brain.Check out this GPT we trained on the conversation!Timestamps00:00 Introduction to the Crazy Wisdom Podcast00:15 Meet the Guests: Ben Ford and Michael Greenberg01:04 Exploring Third Brain and Mission Control03:05 Debating Artificial Intelligence05:24 The Role of AI in Business Operations08:54 Challenges in Digital Transformation16:59 Implementing AI and Digital Operations29:12 Exploring Puzzle App: A New Tool for Documentation30:14 The Power of Graphs in Computer Science32:14 Infinite Dimensions and String Theory32:57 AI Systems and Social Media Content33:31 Wardley Mapping and Business Processes35:26 The Future of AI and Job Security35:49 AI Whisperers Meetup and Conference43:35 The Role of Subject Matter Experts in AI44:13 The Impact of AI on Learning and Careers55:09 Challenges in Implementing AI Chatbots57:10 Closing Thoughts and Contact InformationKey InsightsThe distinction between AI and true intelligence: Ben and Michael both agree that current AI, particularly large language models (LLMs), lacks true intelligence. While these systems are highly capable of pattern recognition and can execute specific workflows efficiently, they fall short of human-like intelligence due to their inability to form cognitive loops, embody real-world understanding, or have agency. AI today excels at capacity but not in truly autonomous thinking.Digital transformation is continuous, not a one-time event: The idea that digital transformation has failed was discussed, with Ben and Michael pointing out that the problem lies in the perception that digital transformation has a start and end point. In reality, businesses are constantly transforming, and the process is more about ongoing adaptation than achieving a static, “transformed” state. Success in this realm requires persistent updates and improvements, especially in operational structure.AI as an enabler, not a replacement: Both guests emphasized that AI should be seen as a tool that augments human capability rather than replaces it. AI can significantly enhance the capacity of knowledge workers, enabling them to focus on more creative or strategic tasks by automating routine processes. However, human oversight and strategic input are still essential, especially when it comes to structuring data and providing context for AI systems to function effectively.The future of work involves "AI whisperers": Stewart introduces the idea of "AI whisperers" — people skilled in communicating with and directing AI systems to achieve specific outcomes. This requires a high level of linguistic and operational understanding, suggesting that those who can finesse AI's capabilities with precision will be in high demand in the future workforce. This shift may see creative, word-focused individuals becoming increasingly critical players in business operations.Structured data is crucial for effective AI deployment: A major challenge in deploying AI for businesses is the lack of well-structured data. Many organizations lack the documentation or system integration needed to effectively implement AI, meaning much of the initial work revolves around organizing data. Without this foundational step, attempts at AI deployment—such as customer service chatbots—are prone to failure, as the AI systems are only as good as the data they're fed.Graphs as the framework for business processes: Ben and Michael both highlight the importance of graphs in modern operations. Graphs, as a way to map out relationships between different elements of a system, are key to understanding and implementing digital operations. This concept allows for the visualization and optimization of workflows, helping businesses better navigate the complexities of modern digital ecosystems.AI is accelerating, and businesses need to keep up: One of the key takeaways from the episode is the rapid pace of AI advancement and its effect on businesses. Companies that fail to incorporate AI tools into their operations risk being left behind. Ben points out that the train has already left the station, and businesses need to quickly adapt by leveraging AI to streamline their processes and maintain competitiveness in an increasingly automated world.

Sophie DeBenedetto and Steven Nunez chat with Ellie Fairholm and Josep Giralt D'Lacoste, authors of Engineering Elixir Applications. https://pragprog.com/titles/beamops/engineering-elixir-applications/ "After reading this book, you'll understand how to apply the BEAMOps principles in your daily work, creating reliable, scalable, and easy to understand applications in a cooperative team environment." - pragprog.com Ellie and Josep are giving a keynote at ElixirConf 2024. https://2024.elixirconf.com/#keynotes We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Twitter @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

Lars chats with Alex McLain and Jon Carstens about NervesConf 2024. @NervesConfUS @JonCarstens @RedwireLabs Nerves MeetUp: https://www.meetup.com/nerves/ We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Twitter @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

Mark Erikson, Redux maintainer and a senior front-end engineer at replay.io discusses why Redux remains a powerful tool for state management in 2024, the evolution of Redux Toolkit, and the common pitfalls developers face. Links https://blog.isquaredsoftware.com https://twitter.com/acemarke https://github.com/markerikson https://stackoverflow.com/users/62937/markerikson https://linkedin.com/in/markerikson We want to hear from you! How did you find us? Did you see us on Twitter? In a newsletter? Or maybe we were recommended by a friend? Let us know by sending an email to our producer, Emily, at emily.kochanekketner@logrocket.com (mailto:emily.kochanekketner@logrocket.com), or tweet at us at PodRocketPod (https://twitter.com/PodRocketpod). Follow us. Get free stickers. Follow us on Apple Podcasts, fill out this form (https://podrocket.logrocket.com/get-podrocket-stickers), and we'll send you free PodRocket stickers! What does LogRocket do? LogRocket provides AI-first session replay and analytics that surfaces the UX and technical issues impacting user experiences. Start understand where your users are struggling by trying it for free at [LogRocket.com]. Try LogRocket for free today.(https://logrocket.com/signup/?pdr) Special Guest: Mark Erikson.

Chris, Lars and Alex discuss Chris's journey into Elixir and using machine learning and AI in Elixir to build a product and a business. They also touch on the process of training models and the benefits of using Livebook. Chris Grainger https://www.amplified.ai We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on Twitter @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)

In this episode, the panel chats with Derrick Reimer, co-founder of SavvyCal. They discuss the advantages of using Elixir for bootstrapped SaaS businesses and how Elixir's functional programming paradigm aligns with modern development practices. Derrick shares his journey from Rails to Elixir and explains why he prefers the clarity and explicitness of Elixir over other languages. @Derrickreimer on X https://savvycal.com We want to connect with you! Twitter: @BeamRadio1 Send us your questions via Twitter @BeamRadio1 #ProcessMailbox Keep up to date with our hosts on X @akoutmos @lawik @meryldakin @RedRapids @smdebenedetto @StevenNunez and on Mastodon @akoutmos@fosstodon.org @lawik@fosstodon.org @redrapids@genserver.social @steven@genserver.social Sponsored by Groxio (https://grox.io) and Underjord (https://underjord.io)