Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin

Elixir Wizards

Player FM - Internet Radio Done Right

79 subscribers

Web Development

הוסף לפני six שנים

תוכן מסופק על ידי SmartLogic LLC. כל תוכן הפודקאסטים כולל פרקים, גרפיקה ותיאורי פודקאסטים מועלים ומסופקים ישירות על ידי SmartLogic LLC או שותף פלטפורמת הפודקאסט שלהם. אם אתה מאמין שמישהו משתמש ביצירה שלך המוגנת בזכויות יוצרים ללא רשותך, אתה יכול לעקוב אחר התהליך המתואר כאן https://he.player.fm/legal.

<div class="span index">1</div> <span><a class="" data-remote="true" data-type="html" href="/series/our-skin-a-personal-discovery-podcast">Our Skin: A Personal Discovery Podcast</a></span>

1
Our Skin: A Personal Discovery Podcast

בטל רישום

לפני 16 hoursלפני 16h ago

בטל רישום

חודשי

Welcome to Our Skin, a Personal Discovery Podcast. Each week, host Holly Frey showcases a personal story from someone who lives–and thrives!--while managing psoriasis. Being diagnosed with a chronic skin condition can throw anyone off track, but Our Skin guests have a message of hope: a diagnosis can be an opportunity to discover new things about ourselves, our grit, and our power. In addition to these tales of hope, Frey and her guests plunge into the jaw-dropping, bizarre, and occasionally poisonous chronicles of our approach to skin conditions – unveiling a history that's far from straightforward! They explore everything from ancient remedies like snake oil to modern dermatology breakthroughs. Whether you’re looking for inspiration on your own skincare journey or are curious about the sometimes strange history of how we treat our skin, you’ll find genuine, empathetic, transformative conversations here on Our Skin.

לפני שנתיים 44:08

MP3•בית הפרקים

The discussion digs into the similarities and differences of actor-based garbage collection in Erlang and Akka and introduces Dan's research on how to perform garbage collection in a distributed actor system.

Topics discussed:

Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering
Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements
Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors
Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes
Challenges include reasoning about failures like dropped messages and crashed nodes
GC balance requires optimization of resource release and CPU load management
Immutability helps Erlang GC, but copying data for messages impacts performance
Research into distributed actor GC is still ongoing, with opportunities for improvement
Fault tolerance in Erlang relies on user implementation rather than low-level guarantees
Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research
Idempotent messaging is recommended to handle possible duplicates from failures
Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases

Links mentioned:

Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i
Scala https://www.scala-lang.org/
Akka Framework https://github.com/akka
JVM (Java Virtual Machine) https://www.java.com/en/download/
The BEAM VM https://www.erlang.org/blog/a-brief-beam-primer/
Hadoop Framework https://hadoop.apache.org/
Pony Programming Language https://www.ponylang.io/
SLSA Programming Language https://wcl.cs.rpi.edu/salsa/#:~:text=SALSA%20
Paxos Algorithm https://en.wikipedia.org/wiki/Paxos_(computer_science)
Raft library for maintaining a replicated state machine https://github.com/etcd-io/raft
Dan's Website https://dplyukhin.github.io/
Dan Plyukhin on Twitter: https://twitter.com/dplyukhin
Dan Plyukhin’s YouTube channel: https://m.youtube.com/@dplyukhin
UIGC on GitHub https://github.com/dplyukhin/UIGC
Manuel's Website https://altenwald.com/
Manuel Rubio on Twitter: https://twitter.com/MRonErlang

Special Guests: Dan Plyukhin and Manuel Rubio.

200 פרקים

#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

Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin

Elixir Wizards

79 subscribers

published לפני שנתיים

שתפו

MP3•בית הפרקים

Topics discussed:

Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering
Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements
Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors
Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes
Challenges include reasoning about failures like dropped messages and crashed nodes
GC balance requires optimization of resource release and CPU load management
Immutability helps Erlang GC, but copying data for messages impacts performance
Research into distributed actor GC is still ongoing, with opportunities for improvement
Fault tolerance in Erlang relies on user implementation rather than low-level guarantees
Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research
Idempotent messaging is recommended to handle possible duplicates from failures
Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases

Links mentioned:

Special Guests: Dan Plyukhin and Manuel Rubio.

200 פרקים

#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
Python in Elixir Apps with Victor Björklund 35:02

לפני 13 hours35:02

35:02

In this episode, Elixir Wizard Charles Suggs sits down with Victor Björklund to map out the landscape of Python integration in Elixir applications. From HTTP APIs and external services to embedded runtimes like ErlPort, PythonX, and the Venomous library, we evaluate each approach’s impact on performance, coupling, and developer experience. Victor draws on real-world examples like Scrapy-based web scraping and the Swedish BankID authentication to illustrate best practices for error handling, process pooling, and effective telemetry across the BEAM boundary. We also tackle the practical side of deployment: packaging Python dependencies in Mix releases, mocking Python calls in tests, and deploying multi-language apps with confidence. Wrapping up, Victor shares his wishlist for even tighter interop (think multiple Python interpreter instances per VM) and offers low-risk entry points, like automating monthly reports, for teams ready to explore the power of Python’s ecosystem within Elixir. Key topics discussed in this episode: Integration methods: HTTP APIs, ports, ErlPort, PythonX, Venomous Performance vs. coupling trade-offs across interop patterns Managing the Global Interpreter Lock (GIL) with process pools Leveraging mature Python libraries (Scrapy, BankID, etc.) Error handling strategies across BEAM↔Python boundaries Testing mixed-language systems: mocks and integration tests Packaging and deploying Python alongside Elixir releases Monitoring and telemetry for multi-language pipelines Functional programming advantages in Elixir workflows Tool selection guidance by project requirements Future possibilities: multiple Python interpreters in one VM Community resources for Python–Elixir interop help Links mentioned: jawdropping.io https://cplusplus.com/ https://www.python.org/ https://react.dev/ https://nodejs.org/en https://erlport.org/ https://hexdocs.pm/pythonx/Pythonx.html https://pyrlang.github.io/Pyrlang/ Python GIL (Global Interpreter Lock): https://realpython.com/python-gil/ https://github.com/devinus/poolboy https://hexdocs.pm/venomous/Venomous.html Try-catch https://syntaxdb.com/ref/python/try-catch https://www.scrapy.org/ https://www.bankid.com/en/ https://www.phoenixframework.org/ https://www.tzeyiing.com/posts/using-a-hunky-poolboy-to-manage-your-python-erlport-processes-in-elixir/ https://medium.com/stuart-engineering/how-we-use-python-within-elixir-486eb4d266f9 https://x.com/bjorklundvictor https://victorbjorklund.com/ https://www.linkedin.com/in/victorbjorklund/ hello@victorbjorklund.com…

Elixir Wizards

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

לפני 8 ימים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

לפני 15 ימים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

לפני 22 ימים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

לפני 29 ימים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

לפני 5 weeks48: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

לפני 6 weeks44: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

לפני 7 weeks38: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

לפני 8 weeks46: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

לפני 9 weeks43: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 weeks54: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 weeks44: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 weeks42: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 weeks52: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 weeks35: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 weeks48: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.…

Elixir Wizards

1
Creating the WebAuthn Components Library for Phoenix LiveView Apps with Owen Bickford 57:32

לפני 37 weeks57:32

57:32

Today on Elixir Wizards, Owen Bickford, fellow Wizard and creator of the WebauthnComponents library, joins us to talk about building passwordless authentication for Phoenix LiveView applications. Owen walks us through the evolution of authentication—touching on everything from plain text passwords to multi-factor setups—and explains the security flaws and user experience issues each method presents. He describes passkeys, a solution based on the WebAuthn API, which improves security and ease of use. The conversation covers cross-device support for passkeys, the role of password managers in keeping credentials synced, and ideas for enhancing WebauthnComponents, like supporting multiple passkeys per account. Owen invites listeners to contribute to the library’s development on GitHub and emphasizes the role passkeys play in improving app security and user experience. Topics discussed in this episode: Passkeys and the shift toward passwordless authentication WebAuthn API and its role in secure login systems Creating the WebauthnComponents library for Phoenix LiveView History of authentication from basic passwords to multi-factor approaches Security gaps and user experience challenges with traditional methods Asymmetric cryptography’s impact on secure logins Hardware-based credential storage and generation with Trusted Platform Modules Structure and components of the WebAuthn library: dependencies, LiveViews, and Ecto schemas Live components for real-time server-browser interactions Passkeys as a primary or secondary authentication method Key business considerations when choosing authentication methods Cross-device support for passkeys and credential syncing Strategies for passkey recovery if devices are lost Ensuring secure access in unattended environments Elixir’s ecosystem advantages for building authentication systems Simplifying JavaScript complexity within Elixir projects Future-proofing WebAuthn Components for seamless updates Using Igniter to enhance customization and refactoring Developer-friendly tools for secure authentication Inviting community contributions on GitHub and the Elixir forum Plans for telemetry and performance tracking Why adopting passkeys is a win for app security and user experience Links mentioned: https://github.com/liveshowy/webauthn_components https://en.wikipedia.org/wiki/Salt_(cryptography) https://en.wikipedia.org/wiki/Rainbow_table https://en.wikipedia.org/wiki/Multi-factor_authentication https://oauth.net/2/ https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API https://www.w3.org/TR/webauthn-3/ https://www.microsoft.com/en-us/windows/tips/windows-hello https://trustedcomputinggroup.org/resource/trusted-platform-module-tpm-summary/ https://hexdocs.pm/phoenix/mix_phx_gen_auth.html https://en.wikipedia.org/wiki/Public-key_cryptography SSH Protocol (Secure Shell) https://en.wikipedia.org/wiki/Secure_Shell https://www.yubico.com/products/yubikey-5-overview/ https://fidoalliance.org/how-fido-works/ https://1password.com/ https://keepassxc.org/ https://hexdocs.pm/ecto_ulid/Ecto.ULID.html https://en.wikipedia.org/wiki/Universally_unique_identifier https://hexdocs.pm/ecto/Ecto.Schema.html https://hexdocs.pm/sourceror/ https://github.com/ash-project/igniter Forum thread: https://elixirforum.com/t/webauthnlivecomponent-passwordless-auth-for-liveview-apps/49941…

Elixir Wizards

1
Creating a Terrestrial Telescope using Nerves & LiveView with Lucas Sifoni 49:56

לפני 38 weeks49:56

49:56

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

Elixir Wizards

1
Creating a Local-First Offline-Enabled LiveView PWA with Tony Dang 48:18

לפני 39 weeks48:18

48:18

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 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-free_replicated_data_type PWA: https://en.wikipedia.org/wiki/Progressive_web_app https://github.com/josevalim/sync https://github.com/sveltejs/svelte https://github.com/woutdp/live_svelte https://github.com/yjs/yjs https://github.com/satoren/y_ex 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 | 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 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.…

Elixir Wizards

1
Creating VintageCell: Nerves, PCBs, and GenStateMachine with Bryan Green 28:58

לפני 40 weeks28:58

28:58

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 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/circuits_gpio Nerves SSH https://hex.pm/packages/nerves_ssh 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/gen_state_machine/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/nerves_system_rpi4/issues/18 https://livebook.dev/ https://codestorm.me/ https://github.com/codestorm1/vintage_cell/ Special Guest: Bryan Green.…

Elixir Wizards

1
Creating the Igniter Code Generation Framework with Zach Daniel 52:55

לפני 41 weeks52:55

52:55

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

Elixir Wizards

1
Elixir Wizards X Thinking Elixir ElixirConf 2024 Hype-isode 59:50

לפני 1 year59:50

59:50

The Elixir Wizards and Thinking Elixir podcasts join forces to bring you a special hype-isode for ElixirConf 2024 in Orlando, Florida. Hosts Owen, Sundi, David, and Mark discuss their favorite moments from past conferences and offer a sneak peek into what this year's event has in store. From insightful training classes to thought-provoking talks on topics like LiveView, data processing, Nerves, and machine learning—there's something for every Elixirist and Elixir-curious software developer. In this episode, we share tips on making the most of the conference, whether you're there to network, learn, or just soak in the community vibes. Want to attend ElixirConf in Orlando from August 27th-30th, 2024? Use code ELIXIRPODCAST at checkout to get a $50 discount on your tickets here: https://ti.to/elixirconf/2024 Key topics discussed in this episode: Favorite moments and experiences from previous ElixirConf events How to network and make the most of your conference attendance Training classes and talks we're looking forward to this year Keynotes from prominent Elixir community figures Chris McCord's keynote: TBD (Could it be a LiveView 1.0 announcement?!) Benefits of attending ElixirConf: learning, networking, community immersion Virtual attendance options for those unable to attend in person Early bird ticket prices and special discount code "ELIXIRPODCAST" for $50 off Why you should step out of your comfort zone and engage with others Passion and energy of Elixir community members at ElixirConf Mentorship opportunities: connect with experienced Elixir developers Exploring Orlando attractions during ElixirConf 2024 downtime An invitation to join us at ElixirConf 2024 and immerse yourself in the Elixir community Links mentioned: https://2024.elixirconf.com/ https://hexdocs.pm/ecto/Ecto.html https://fly.io/ https://brainlid.org/ https://github.com/brainlid/ https://www.meetup.com/austin-elixir/ https://grox.io/ https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html https://opentelemetry.io/docs/languages/erlang/ https://ash-hq.org/ https://alembic.com.au/ Functional IoT with Elixir and Nerves - Justin Schneck | Craft 2019 https://docs.nerves-hub.org/ https://nerves-project.org/ https://getoban.pro/ https://hexdocs.pm/broadway/Broadway.html https://developer.farm.bot/v15/docs/farmbot-os.html Leaving Everything Behind For Elixir - Theo’s video Phoenix LiveView Is Making Me Reconsider React... - Theo’s other video Podcast: Thinking Elixir 206: BeamOps - DevOps on the BEAM Special Guests: David Bernheisel and Mark Ericksen.…

Elixir Wizards

1
"The Past is Your Teacher" with Alicia Brindisi and Bri LaVorgna 32:56

לפני 1 year32:56

32:56

It’s the season finale of Elixir Wizards Office Hours! SmartLogic’s Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join host Dan to delve into the agile ceremony of retrospectives. They explore the vital role of retrospectives in Agile project management and unveil practical strategies for enhancing their effectiveness. Alicia and Bri break down the elements of a successful retrospective. They cover everything from meticulous preparation to facilitation techniques, and how to choose the best format for fostering open dialogue and actionable results. Learn how to navigate common obstacles and guide discussions toward productive, solution-focused outcomes. Throughout the episode, they emphasize the transformative potential of retrospectives within the Agile framework, portraying them not just as a procedural activity, but as a catalyst for continuous team growth and project success. Key topics discussed in this episode: Mastering the full potential of retrospectives in Agile environments Best practices for effective preparation and facilitation Choosing the right format to suit your team's dynamics Strategies for overcoming typical challenges during retrospectives Techniques for addressing and resolving interpersonal conflicts constructively The critical importance of valuing each team member’s perspective Practical advice on applying insights from retrospectives to enact organizational changes Tailoring and refining retrospectives to meet your team’s unique requirements Links mentioned: SmartLogic https://smartlogic.io/ SmartLogic LinkedIn https://www.linkedin.com/company/smartlogic-io Contact Bri Bri@smartlogic.io Retrium Retrospectives for Scrum & Agile Teams https://www.retrium.com/ 4Ls Retrospective Template https://www.retrium.com/retrospective-techniques/4ls Start Stop Continue Retrospective https://www.retrium.com/retrospective-techniques/start-stop-continue Sailboat Retrospective https://www.retrium.com/retrospective-techniques/sailboat Starfish Retrospective https://www.retrium.com/retrospective-techniques/starfish ClickUp Project Management Platform https://clickup.com/teams/project-management Asana Task Manager http://www.asana.com Jira Project Management Tool https://www.atlassian.com/software/jira Special Guests: Alicia Brindisi and Bri LaVorgna.…

Elixir Wizards

1
"So You've Been Hired" with Emma Whamond and Micaela Cunha 46:06

לפני 1 year46:06

46:06

In Office Hours Episode 10, SmartLogic’s newest developers, Emma Whamond and Micaela Cunha, join Elixir Wizard Owen Bickford to discuss their onboarding experiences, joining a new engineering team, and navigating an unfamiliar codebase. They share tips and challenges on learning new programming languages like Ruby and Elixir while ramping up for active client projects. Emma and Micaela emphasize the value of starting with tests and seeking guidance from teammates when diving into unfamiliar projects. Our guests provide valuable guidance for anyone navigating the transition into a new software development team, highlighting the importance of collaboration, continuous learning, and community support in the tech industry. Key topics discussed in this episode: What to expect when joining a new engineering team Navigating existing codebases as a new hire in Elixir and Ruby Applying previous work experience to software development The importance of tests and team communication in unfamiliar projects Learning Ruby as a C++ and JavaScript developer Differences between dynamic and static typing Building team camaraderie and intentionality in remote work environments The steep learning curve of the onboarding process, including documentation, codebases, and client meetings Relying on teammates for guidance and overcoming the fear of asking too many questions Updating documentation within project repositories Learning team dynamics and identifying domain experts for targeted assistance Domain-specific knowledge: being a senior developer in one language vs. another Building friendships and connections within local tech communities The welcoming and supportive nature of the tech industry for newcomers Links mentioned: Elixir Programming Language https://elixir-lang.org/ Ruby on Rails https://www.ruby-lang.org/en/ Ruby Koans - Learn Ruby language, syntax, structure https://www.rubykoans.com/ Elixir Language Learning Exercises (Elixir Koans) https://github.com/elixirkoans/elixir-koans The PETAL Stack in Elixir https://thinkingelixir.com/petal-stack-in-elixir/ Alpine JS Lightweight JavaScript Framework https://alpinejs.dev/ Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html WebAuthn Components passwordless authentication to LiveView applications https://github.com/liveshowy/webauthn_components Gleam functional language for building type-safe, scalable systems https://gleam.run/ The Future of Types in Elixir with José Valim, Guillaume Duboc, and Giuseppe Castagna https://smartlogic.io/podcast/elixir-wizards/s10-e12-jose-guillaume-giuseppe-types-elixir/ Git-Blame https://git-scm.com/docs/git-blame nix store https://nixos.org/manual/nix/stable/command-ref/nix-store Code and Coffee https://codeandcoffee.org/ Special Guests: Emma Whamond and Micaela Cunha.…

Elixir Wizards

1
"From Inspiration to Execution" with Camber Griffin 45:03

לפני 1 year45:03

45:03

In Episode 9 of Elixir Wizards Office Hours, we dive into task writing and backlog grooming, transforming ideas from the discovery phase into actionable tickets. Join SmartLogic Developer Camber Griffin and hosts Dan Ivovich and Owen Bickford as they explore the intricacies of task writing, ticket grooming, estimation, and backlog management in the software development lifecycle. They emphasize crafting clear, detailed tickets that act as comprehensive guides for development teams. A well-written ticket does more than outline what needs to be built—it facilitates collaboration by including entry points, linking to essential documentation, defining acceptance criteria, detailing QA steps, and identifying potential risks and future hurdles. Key topics discussed in this episode: Crafting actionable development tickets from inspiration Achieving the optimal level of detail in tickets Tailoring ticket content for developers, QA, and stakeholders Standardizing ticket format with templates Structurally breaking down tasks into manageable sections Ensuring flexibility in implementation while maintaining clear specifications Proactively discussing architectural and design approaches Incorporating related documentation within tickets Clarifying acceptance criteria and QA procedures Accurately estimating task effort and complexity Collaboratively grooming tasks with cross-functional teams Adjusting tickets to evolving requirements Strategically planning for uncertainties and out-of-scope concerns Managing and versioning ongoing documentation Keeping the backlog clean, prioritized, and relevant Mapping dependencies among interconnected tasks Links mentioned: Jira Work Management https://www.atlassian.com/software/jira ClickUp Project Management Platform https://clickup.com/teams/project-management GitHub Projects https://docs.github.com/en/issues/planning-and-tracking-with-projects Zube Agile Project Management https://zube.io/ Pivotal Tracker Agile Project Management Tool https://www.pivotaltracker.com/ Trak Portfolio Management System https://pd-trak.com/ ClearCase Software Configuration Mgmt www.ibm.com/products/devops-code-clearcase Oban Job Processing in Elixir https://github.com/sorentwo/oban Special Guest: Camber Griffin.…

Elixir Wizards

1
"DevOps: From Code to Cloud" with Dan Ivovich 43:43

לפני 1 year43:43

43:43

In Elixir Wizards Office Hours Episode 8, hosts Sundi Myint and Owen Bickford lead an engaging Q&A session with co-host Dan Ivovich, diving deep into the nuances of DevOps. Drawing from his extensive experience, Dan navigates topics from the early days before Docker to managing diverse polyglot environments and optimizing observability. This episode offers insights for developers of all levels looking to sharpen their DevOps skills. Explore the realms of Docker, containerization, DevOps workflows, and the deployment intricacies of Elixir applications. Key topics discussed in this episode: Understanding DevOps and starting points for beginners Best practices for deploying applications to the cloud Using Docker for containerization Managing multiple programming environments with microservices Strategies for geographic distribution and ensuring redundancy Localization considerations involving latency and device specs Using Prometheus and OpenTelemetry for observability Adjusting scaling based on application metrics Approaching failure scenarios, including database migrations and managing dependencies Tackling challenges in monitoring setups and alert configurations Implementing incremental, zero-downtime deployment strategies The intricacies of hot code upgrades and effective state management Recommended learning paths, including Linux and CI/CD workflows Tools for visualizing system health and monitoring Identifying actionable metrics and setting effective alerts Links mentioned: Ansible open source IT automation engine https://www.ansible.com/ Wikimedia engine https://doc.wikimedia.org/ Drupal content management software https://www.drupal.org/ Capistrano remote server automation and deployment https://capistranorb.com/ Docker https://www.docker.com/ Circle CI CI/CD Tool https://circleci.com/ DNS Cluster https://hex.pm/packages/dns_cluster ElixirConf 2023 Chris McCord Phoenix Field Notes https://youtu.be/Ckgl9KO4E4M Nerves https://nerves-project.org/ Oban job processing in Elixir https://getoban.pro/ Sidekiq background jobs for Ruby https://sidekiq.org/ Prometheus https://prometheus.io/ PromEx https://hexdocs.pm/prom_ex/PromEx.html GitHub Actions - Setup BEAM: https://github.com/erlef/setup-beam Jenkins open source automation server https://www.jenkins.io/ DataDog Cloud Monitoring https://www.datadoghq.com/…

Elixir Wizards

1
"Printing is Ugly" with Joel Meador and Charles Suggs 47:03

לפני 1 year47:03

47:03

In Episode 7 of Elixir Wizards Office Hours, SmartLogic Engineers Joel Meador and Charles Suggs join host Owen Bickford to tackle the often tricky task of adding print functionality to web applications. They discuss their recent experiences with browser-based printing and the hurdles of cross-browser compatibility, consistent styling, and dynamic content generation, such as headers and footers. The trio delves into the limitations of current printing capabilities in browsers, the potential of server-side PDF generation, and the necessity of juggling separate templates for web and print. They also consider accessibility for printed content and the demands of delivering high-fidelity, pixel-perfect prints. Throughout the episode, Joel, Charles, and Owen offer up practical advice for developers grappling with similar issues, emphasizing the need for thorough research, proactive problem-solving, and the exploration of both in-browser and external PDF generation solutions. Key topics discussed in this episode: Real-world experiences with software project printing Navigating the limitations of browser-based printing Ensuring cross-browser compatibility and consistent layout Generating dynamic content for print versions Exploring server-side PDF generation and its advantages Balancing design consistency across web and print formats Addressing accessibility in printed outputs Overcoming the unique challenges of high-accuracy printing requirements Practical tips for researching and implementing printing solutions Handling complex data presentations like tables in print Evaluating the pros and cons of different printing APIs Understanding the distinction between web viewing and printing needs Innovating with mixed content in PDF generation Learning from past printing challenges and planning for future improvements Links mentioned: CSS3 https://css3.com/ WeasyPrint https://github.com/Kozea/WeasyPrint WebKit https://webkit.org/ Pdf.js https://github.com/mozilla/pdf.js YesLogic Prince 15 https://www.princexml.com/ PrintXML https://gist.github.com/craiga/2934093 PDF/A https://en.wikipedia.org/wiki/PDF/A The PDF/A Family of Archiving Standards https://www.pdflib.com/pdf-knowledge-base/pdfa/the-pdfa-standards/ PDF/X https://en.wikipedia.org/wiki/PDF/X Microsoft Encarta https://en.wikipedia.org/wiki/Encarta Special Guests: Charles Suggs and Joel Meador.…

Elixir Wizards

1
"Keeping it Fresh" with Bilal Hankins and Anna Dorigo 36:00

לפני 1 year36:00

36:00

In Office Hours Episode 6, SmartLogic Developers Anna Dorigo and Bilal Hankins join Elixir Wizards Sundi and Dan to discuss their experiences maintaining a decade-old Ruby on Rails codebase. They delve into the critical importance of deeply understanding the codebase, keeping dependencies current, and adapting to the original application's evolving priorities and design choices. The conversation spans a range of topics, including accessibility, testing, monitoring, and the challenges of deploying database migrations in production environments. The guests share effective strategies for sustaining and enhancing older codebases, such as employing automated tools, performing code audits, and adhering to clean coding principles. Key topics discussed in this episode: Grasping the legacy codebase and its historical context Overcoming accessibility issues in older applications Safe dependency management and upgrades The effects of application scaling on database performance The critical role of comprehensive test suites in legacy systems Using tools like Sentry for error tracking and performance monitoring The benefits of automated security and dependency scans Juggling client needs with budget constraints Local simulation techniques for large datasets The value of iterative code reviews and maintaining clean code Utilizing git history for contextual understanding Onboarding strategies for legacy projects Removing obsolete code and avoiding "magic numbers" Importance of descriptive naming for better code clarity Leveraging a rich repository of example code for learning and reference Proactive code audits to anticipate issues Managing pull request sizes for smoother reviews Communicating effectively about upgrades and potential impacts Strategies for handling large databases efficiently Ensuring thorough test coverage Keeping open lines of communication with clients regarding ongoing maintenance Links mentioned: COBOL programming language https://developer.ibm.com/languages/cobol/ Ruby on Rails https://rubyonrails.org/ ARIA Rules (Accessible Rich Internet Applications) https://www.w3.org/TR/using-aria/ Shawn Vo on Elixir as a Competitive Advantage https://smartlogic.io/podcast/elixir-wizards/s5e5-vo/ Bundler Audit Ruby Gem https://rubygems.org/gems/bundler-audit/ Sentry application monitoring and error tracking software https://sentry.io/ Dependabot Github automated dependency updates Mix hex.audit https://hexdocs.pm/hex/Mx.Tasks.Hex.Audit.html Git Blame https://git-scm.com/docs/git-blame Cow hoof trimming videos - The Hoof GP on YouTube (TW graphic imagery) Special Guests: Anna Dorigo and Bilal Hankins.…

Elixir Wizards

1
"Saga of a Gnarly Report" with Owen and Dan 50:21

לפני 1 year50:21

50:21

In today's episode, Elixir Wizards Owen and Dan delve into the complexities of building advanced reporting features within software applications. They share personal insights and challenges encountered while developing reporting solutions for user-generated data, leveraging both Elixir/Phoenix and Ruby on Rails. The discussion zeroes in on crucial data modeling and architectural decisions that enhance reporting efficiency and flexibility. Owen and Dan explore tactics like materialized views, event sourcing, and database triggers to optimize data handling while being mindful of UX elements like progress indicators and background job management. They share insights on leveraging the Elixir/Beam ecosystem’s strengths—like concurrency and streamlined deployment—to tackle common reporting, caching, and integration challenges. The episode highlights the impact of reporting features across all aspects of a software application’s design and architecture. Key topics discussed in this episode: Reporting on assessment data, survey results, and user metrics Differences between reporting and performance/error monitoring Implementing reporting in Elixir/Phoenix vs. Ruby on Rails Displaying reports in web, printable, PDF, SVG, and CSV formats Challenges of generating PDFs for large data sets Streaming CSV data directly to the client Handling long-running report generation tasks Providing progress indicators and user notifications Strategies for canceling or abandoning incomplete reports Tradeoffs of pre-calculating report data vs. real-time generation Materializing views and denormalizing data for reporting Exploring event sourcing patterns for reporting needs Using database triggers and stored procedures for reporting Balancing data structure optimization for reports vs. day-to-day usage Caching report data for faster retrieval and rendering Charting and visualization integration in reporting systems Links mentioned: Prometheus monitoring system & time series database https://prometheus.io/ Thinking Elixir "FLAME with Chris McCord" https://podcast.thinkingelixir.com/181 Phoenix LiveView Uploads https://hexdocs.pm/phoenix/file_uploads.html https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.UploadWriter.html Postgrex PostgreSQL driver for Elixir https://hexdocs.pm/postgrex/Postgrex.html Ecto https://hexdocs.pm/ecto/Ecto.html Heroku cloud application platform https://www.heroku.com/ Elixir Wizards S9E12 Marcelo Dominguez on Command and Query Responsibility Segregation https://smartlogic.io/podcast/elixir-wizards/s9-e12-marcelo-dominguez-cqrs/ Commanded Elixir CQRS/ES applications https://github.com/commanded/commanded Tailwind CSS Framework https://github.com/tailwindlabs Memcached https://memcached.org/ Redis https://redis.io/ Oban https://hexdocs.pm/oban/Oban.html ETS https://hexdocs.pm/ets/ETS.html Capistrano remote server automation and deployment tool https://capistranorb.com/…

Elixir Wizards

1
"Whose Tailwind is it Anyway?" with Ava Slivkoff 48:17

לפני 1 year48:17

48:17

In Elixir Wizards Office Hours Episode 4, SmartLogic Product Designer Ava Slivkoff joins hosts Sundi Myint and Owen Bickford to discuss the product designer's role in software development. Ava shares her experience navigating client expectations, software design principles, and technical constraints. They explore the integration of design and development workflows and how designers and engineers can collaborate to meet a project's specific needs. The conversation emphasizes the value of cross-functional teams and the synergy that can arise when all team members work in harmony to bring a product to life. Key concepts discussed in the episode: The broad scope of the designer role in web app development The value of an MVP in the iterative software design process Challenges of aligning client expectations with design best practices Pros and cons of leveraging pre-built Tailwind CSS styled components Trends and evolution in web design aesthetics and patterns Leveraging open-source design systems like Tailwind UI Balancing technical constraints with design aspirations Communication and trust-building between designers and engineers Workflows for design handoffs and feedback loops Importance of user flows and mapping the product experience Challenges around the implementation of complex UI elements Benefits of regular design review meetings and syncs Fostering empathy and collaboration across disciplines Links mentioned Figma Dev Mode https://www.figma.com/dev-mode/ Tailwind CSS utility-first CSS framework https://tailwindcss.com/ Tailwind UI https://tailwindui.com/ https://devinai.ai/ Special Guest: Ava Slivkoff.…

Elixir Wizards

1
"You've Got a Job to Do" with Joel Meador 44:26

לפני 1 year44:26

44:26

Today on Elixir Wizards Office Hours, SmartLogic Engineer Joel Meador joins Dan Ivovich to discuss all things background jobs. The behind-the-scenes heroes of app performance and scalability, background jobs take center stage as we dissect their role in optimizing user experience and managing heavy-lifting tasks away from the main application flow. From syncing with external systems to processing large datasets, background jobs are pivotal to successful application management. Dan and Joel share their perspectives on monitoring, debugging, and securing background jobs, emphasizing the need for a strategic approach to these hidden workflows. Key topics discussed in this episode: The vital role of background jobs in app performance Optimizing user experience through background processing Common pitfalls: resource starvation and latency issues Strategies for effective monitoring and debugging of task runners and job schedulers Data integrity and system security in open source software Background job tools like Oban, Sidekiq, Resque, Cron jobs, Redis pub sub CPU utilization and processing speed Best practices for implementing background jobs Keeping jobs small, focused, and well-monitored Navigating job uniqueness, locking, and deployment orchestration Leveraging asynctask for asynchronous operations The art of continuous improvement in background job management Links mentioned in this episode: https://redis.io/ Oban job processing library https://hexdocs.pm/oban/Oban.html Resque Ruby library for background jobs https://github.com/resque Sidekiq background processing for Ruby https://github.com/sidekiq Delayed Job priority queue system https://github.com/collectiveidea/delayed_job RabbitMQ messaging and streaming broker https://www.rabbitmq.com/ Mnesia distributed telecommunications DBMS https://www.erlang.org/doc/man/mnesia.html Task for Elixir https://hexdocs.pm/elixir/1.12/Task.html ETS in-memory store for Elixir and Erlang objects https://hexdocs.pm/ets/ETS.html Cron - https://en.wikipedia.org/wiki/Cron Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action Joel Meador on Tumblr https://joelmeador.tumblr.com/ Special Guest: Joel Meador.…

Elixir Wizards

1
"Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna 43:26

לפני 1 year43:26

43:26

In Elixir Wizards Office Hours Episode 2, "Discovery Discoveries," SmartLogic's Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join Elixir Wizards Sundi Myint and Owen Bickford on an exploratory journey through the discovery phase of the software development lifecycle. This episode highlights how collaboration and communication transform the client-project team dynamic into a customized expedition. The goal of discovery is to reveal clear business goals, understand the end user, pinpoint key project objectives, and meticulously document the path forward in a Product Requirements Document (PRD). The discussion emphasizes the importance of fostering transparency, trust, and open communication. Through a mutual exchange of ideas, we are able to create the most tailored, efficient solutions that meet the client's current goals and their vision for the future. Key topics discussed in this episode: Mastering the art of tailored, collaborative discovery Navigating business landscapes and user experiences with empathy Sculpting project objectives and architectural blueprints Continuously capturing discoveries and refining documentation Striking the perfect balance between flexibility and structured processes Steering clear of scope creep while managing expectations Tapping into collective wisdom for ongoing discovery Building and sustaining a foundation of trust and transparency Links mentioned in this episode: https://smartlogic.io/ Follow SmartLogic on social media: https://twitter.com/smartlogic Contact Bri: bri@smartlogic.io What is a PRD? https://en.wikipedia.org/wiki/Product_requirements_document Special Guests: Alicia Brindisi and Bri LaVorgna.…

Elixir Wizards

1
"Testing 1, 2, 3" with Joel Meador and Charles Suggs 45:40

לפני 1 year45:40

45:40

The Elixir Wizards Podcast is back with Season 12 Office Hours, where we talk with the internal SmartLogic team about the stages of the software development lifecycle. For the season premiere, "Testing 1, 2, 3," Joel Meador and Charles Suggs join us to discuss the nuances of software testing. In this episode, we discuss everything from testing philosophies to test driven development (TDD), integration, and end-user testing. Our guests share real-world experiences that highlight the benefits of thorough testing, challenges like test maintenance, and problem-solving for complex production environments. Key topics discussed in this episode: How to find a balance that's cost-effective and practical while testing Balancing test coverage and development speed The importance of clear test plans and goals So many tests: Unit testing, integration testing, acceptance testing, penetration testing, automated vs. manual testing Agile vs. Waterfall methodologies Writing readable and maintainable tests Testing edge cases and unexpected scenarios Testing as a form of documentation and communication Advice for developers looking to improve testing practices Continuous integration and deployment Links mentioned: https://smartlogic.io/ Watch this episode on YouTube! youtu.be/u_nx5AIvSdc Bob Martin “Clean Code” videos - “Uncle Bob”: http://cleancoder.com/ JUnit 5 Testing for Java and the JVM https://junit.org/junit5/ ExUnit Testing for Elixir https://hexdocs.pm/ex_unit/ExUnit.html Code-Level Testing of Smalltalk Applications https://www.cs.ubc.ca/~murphy/st_workshop/28-7.html Agile Manifesto https://agilemanifesto.org/ Old Man Yells at Cloud https://i.kym-cdn.com/entries/icons/original/000/019/304/old.jpg TDD: Test Driven Development https://www.agilealliance.org/glossary/tdd/ Perl Programming Language https://www.perl.org/ Protractor Test Framework for Angular and AngularJS protractortest.org/#/ Waterfall Project Management https://business.adobe.com/blog/basics/waterfall CodeSync Leveling up at Bleacher Report A cautionary tale - PETER HASTIE https://www.youtube.com/watch?v=P4SzZCwB8B4 Mix ecto.dump https://hexdocs.pm/ecto_sql/Mix.Tasks.Ecto.Dump.html Apache JMeter Load Testing in Java https://jmeter.apache.org/ Pentest Tools Collection - Penetration Testing https://github.com/arch3rPro/PentestTools The Road to 2 Million Websocket Connections in Phoenix https://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action Joel Meador on Tumblr https://joelmeador.tumblr.com/ Special Guests: Charles Suggs and Joel Meador.…

Elixir Wizards

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

לפני 2 years1:09:04

1:09:04

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

Elixir Wizards

1
Package Management in Elixir vs. JavaScript with Wojtek Mach & Amal Hussein 54:06

לפני 2 years54:06

54:06

Today on Elixir Wizards, Wojtek Mach of HexPM and Amal Hussein, engineering leader and former NPM team member, join Owen Bickford to compare notes on package management in Elixir vs. JavaScript. This lively conversation covers everything from best practices for dependency management to API design, SemVer (semantic versioning), and the dark ages of web development before package managers existed. The guests debate philosophical differences between the JavaScript and Elixir communities. They highlight the JavaScript ecosystem's maturity and identify potential areas of improvement, contrasted against Elixir’s emphasis on minimal dependencies. Both guests encourage engineers to publish packages, even small ones, as a learning opportunity. Topics discussed in this episode: Leveraging community packages rather than reinventing the wheel Vetting packages carefully before adopting them as dependencies Evaluating security, performance, and bundle size when assessing packages Managing transitive dependencies pulled in by packages Why semantic versioning is difficult to consistently enforce Designing APIs with extensibility and backward compatibility in mind Using tools like deprecations to avoid breaking changes in new releases JavaScript’s preference for code reuse over minimization The Elixir community’s minimal dependencies and avoidance of tech debt Challenges in early package management, such as global dependency Learning from tools like Ruby Gems and Bundler to improve experience How log files provide visibility into dependency management actions How lock files pin dependency versions for consistency Publishing packages democratizes access and provides learning opportunities Linting to enforce standards and prevent certain bugs Primitive-focused packages provide flexibility over highly opinionated ones Suggestions for improving documentation and guides Benefits of collaboration between programming language communities Links mentioned in this episode: Node.js https://github.com/nodejs npm JavaScript Package Manager https://github.com/npm JS Party Podcast https://changelog.com/jsparty Dashbit https://dashbit.co/ HexPM Package Manager for Erlang https://hex.pm/ HTTP Client for Elixir https://github.com/wojtekmach/req Ecto Database-Wrapper for Elixir https://github.com/elixir-ecto (Not an ORM) XState Actor-Based State Management for JavaScript https://xstate.js.org/docs/ Supply Chain Protection for JavaScript, Python, and Go https://socket.dev/ MixAudit https://github.com/mirego/mix_audit NimbleTOTP Library for 2FA https://hexdocs.pm/nimble_totp/NimbleTOTP.html Microsoft Azure https://github.com/Azure Patch Package https://www.npmjs.com/package/patch-package Ruby Bundler to manage Gem dependencies https://github.com/rubygems/bundler npm-shrinkwrap https://docs.npmjs.com/cli/v10/commands/npm-shrinkwrap SemVer Semantic Versioner for NPM https://www.npmjs.com/package/semver Spec-ulation Keynote - Rich Hickey https://www.youtube.com/watch?v=oyLBGkS5ICk Amal’s favorite Linter https://eslint.org/ Elixir Mint Functional HTTP Client for Elixir https://github.com/elixir-mint Tailwind Open Source CSS Framework https://tailwindcss.com/ WebauthnComponents https://hex.pm/packages/webauthn_components Special Guests: Amal Hussein and Wojtek Mach.…

Elixir Wizards

1
Communities in Tech with Camille Clayton & Scott Tolinski 48:19

לפני 2 years48:19

48:19

Today on Elixir Wizards, Camille Clayton, Director of Women Who Code DC, and Scott Tolinski, Co-Host of the Syntax Podcast and Creator of Level Up Tutorials, join hosts Sundi Myint and Owen Bickford to discuss tech community spaces online and IRL. They lay out the blueprint and best practices for fostering an inclusive environment where newcomers feel comfortable and welcome to join the discussion – whether it’s an online forum, YouTube comment sections, social media platform, local meetup, or conference. Topics discussed in this episode: Leaving a space open so newcomers feel empowered to join Celebrating small wins to maintain excitement and build confidence Why consistency is key to building a community with longevity Creating and enforcing a code of conduct to define expectations Finding respectful resolutions for addressing issues or complaints The importance of amplifying underrepresented voices in tech Creating content for all skill levels and adapting to a wider audience How remote meetups broaden the possibilities for attendance and connection Finding the right fit for mentorship Delegation to strengthen community members’ sense of ownership Navigating the new normal of local, in-person gatherings post-pandemic Links mentioned in this episode: https://www.womenwhocode.com/network/dc https://syntax.fm/ https://levelup.video/ https://devopsdays.org/ https://github.com/sveltejs https://github.com/womenwhocodedc https://twitter.com/womenwhocode https://www.remoteworkcalc.com/ https://twitter.com/WomenWhoCodeDC https://www.meetup.com/dc-elixir/ Special Guests: Camille Clayton and Scott Tolinski.…

Elixir Wizards

1
Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler 47:57

לפני 2 years47:57

47:57

In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure. In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads. They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project. Topics discussed in this episode: Difference between actor model and shared memory concurrency Isolation of actor state and communication via message passing BEAM VM design for high concurrency via lightweight processes GenServers as common abstraction for building stateful actors GenServer callbacks for message handling and state updates Agents as similar process abstraction to GenServers Shared state utilities like ETS for inter-process communication Global Interpreter Lock in older Ruby VMs Ractors as initial actor implementation in Ruby mapping to threads Planned improvements to Ruby concurrency in 3.3 Akka implementation of actor model on JVM using thread scheduling Limitations of shared memory concurrency on JVM Project Loom bringing lightweight processes to JVM Building GenServer behavior in Ruby using metaprogramming CSP model of communication using channels in Clojure Differences between BEAM scheduler and thread-based VMs Comparing Elixir to academic languages like Haskell Remote and theScore are hiring! Links mentioned in this episode: theScore is hiring! https://www.thescore.com/ Remote is also hiring! https://remote.com/ Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022 Clojure Programming Language https://clojure.org/ Akka https://akka.io/ Go Programming Language https://github.com/golang/go Proto Actor for Golang https://proto.actor/ RabbitMQ Open-Source Message Broker Software https://github.com/rabbitmq JVM Project Loom https://github.com/openjdk/loom Ractor for Ruby https://docs.ruby-lang.org/en/master/ractor_md.html Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher Seven Languages in Seven Weeks by Bruce A. Tate GenServer https://hexdocs.pm/elixir/1.12/GenServer.html ets https://www.erlang.org/doc/man/ets.html Elixir in Action by Saša Jurić Redis https://github.com/redis/redis Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users Xiang's website https://xiangji.me/ Feeling Good: The New Mood Therapy by David D. Burns Special Guests: Nathan Hessler and Xiang Ji.…

Elixir Wizards

1
Static Code Analysis in Elixir vs. Ruby with René Föhring & Marc-André Lafortune 46:02

לפני 2 years46:02

46:02

In this episode of Elixir Wizards, hosts Owen and Dan are joined by René Föhring, creator of Credo for Elixir, and Marc-André LaFortune, head maintainer of the RuboCop AST library for Ruby. They compare static code analysis in Ruby versus Elixir. The conversation explores the intricacies and challenges inherent in static code analysis across object-oriented and functional programming paradigms, highlighting the unique characteristics of both Ruby and Elixir. Key topics of discussion include the ways these tools can enhance coding styles and empower developers, the delicate balance between providing guidance and enforcing rules, and the evolving future of code analysis in these languages. Topics discussed in this episode: The differences and applications between static and dynamic analysis How Credo aims to offer flexible and educational guidance for Elixir developers The complexities of method identification in Ruby and its impact on static analysis Challenges posed by macros and dynamic code modification during compilation in Elixir Reducing false positives in code analysis tools to minimize developer frustration Promoting uniform coding practices through analysis tools The significance of using analysis tools with clear, specific objectives How coding standards can refine and improve coding styles over time Building analysis tools and checks through an understanding of Abstract Syntax Trees (ASTs) Potential advancements in the analysis of Phoenix templates and HTML in Elixir Contrasting approaches to managing code and comments in Elixir and Ruby ASTs The fine line between providing helpful guidance and imposing stylistic preferences Heuristics in static analysis highlight inconsistencies without mandating style The potential for more straightforward pattern matching in ASTs with future updates The importance of a gradual implementation of tool updates to maintain backward compatibility Creating tools that support and empower developers, rather than hinder them How static analysis contributes to cleaner, more maintainable codebases Potential future developments in the field of static code analysis Practical applications of using linters like Credo and RuboCop in software development Links mentioned in this episode: Credo https://github.com/rrrene/credo https://hexdocs.pm/credo/overview.html Dogma: A code style linter for Elixir https://github.com/lpil/dogma https://github.com/rubocop/rubocop RuboCop's AST extensions and NodePattern functionality https://github.com/rubocop/rubocop-ast https://github.com/whitequark/parser https://hex.pm/packages?search=credo&sort=recent_downloads https://github.com/doorgan/sourceror https://github.com/rrrene/credo/blob/master/lib/credo/check/readability/large_numbers.ex Special Guests: Marc-André Lafortune and René Föhring.…

Elixir Wizards

1
Web Development Frameworks: Elixir and Phoenix vs. Ruby on Rails with Owen Bickford & Dan Ivovich 41:41

לפני 2 years41:41

41:41

On today’s episode, Elixir Wizards Owen Bickford and Dan Ivovich compare notes on building web applications with Elixir and the Phoenix Framework versus Ruby on Rails. They discuss the history of both frameworks, key differences in architecture and approach, and deciding which programming language to use when starting a project. Both Phoenix and Rails are robust frameworks that enable developers to build high-quality web apps—Phoenix leverages functional programming in Elixir and Erlang’s networking for real-time communication. Rails follows object-oriented principles and has a vast ecosystem of plug-ins. For data-heavy CRUD apps, Phoenix's immutable data pipelines provide some advantages. Developers can build great web apps with either Phoenix or Rails. Phoenix may have a slight edge for new projects based on its functional approach, built-in real-time features like LiveView, and ability to scale efficiently. But, choosing the right tech stack depends heavily on the app's specific requirements and the team's existing skills. Topics discussed in this episode: History and evolution of Phoenix Framework and Ruby on Rails Default project structure and code organization preferences in each framework Comparing object-oriented vs functional programming paradigms CRUD app development and interaction with databases Live reloading capabilities in Phoenix LiveView vs Rails Turbolinks Leveraging WebSockets for real-time UI updates Testing frameworks like RSpec, Cucumber, Wallaby, and Capybara Dependency management and size of standard libraries Scalability and distribution across nodes Readability and approachability of object-oriented code Immutability and data pipelines in functional programming Types, specs, and static analysis with Dialyzer Monkey patching in Ruby vs extensible core language in Elixir Factors to consider when choosing between frameworks Experience training new developers on Phoenix and Rails Community influences on coding styles Real-world project examples and refactoring approaches Deployment and dev ops differences Popularity and adoption curves of both frameworks Ongoing research into improving Phoenix and Rails Links Mentioned in this Episode: SmartLogic.io Dan’s LinkedIn Owen’s LinkedIn Ruby https://www.ruby-lang.org/en/ Rails https://rubyonrails.org/ Sams Teach Yourself Ruby in 21 Days Learn Ruby in 7 Days Build Your Own Ruby on Rails Web Applications Django https://github.com/django Sidekiq https://github.com/sidekiq Kafka https://kafka.apache.org/ Phoenix Framework https://www.phoenixframework.org/ Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#content Flask https://flask.palletsprojects.com/en/3.0.x/ WebSockets API https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API WebSocket connection for Phoenix https://github.com/phoenixframework/websock Morph Dom https://github.com/patrick-steele-idem/morphdom Turbolinks https://github.com/turbolinks Ecto https://github.com/elixir-ecto Capybara Testing Framework https://teamcapybara.github.io/capybara/ Wallaby Testing Framework https://wallabyjs.com/ Cucumber Testing Framework https://cucumber.io/ RSpec https://rspec.info/…

Elixir Wizards

1
Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin 44:08

לפני 2 years44:08

44:08

Today on Elixir Wizards, Manuel Rubio, author of Erlang/OTP: A Concurrent World and Dan Plyukhin, creator of the UIGC Actor Garbage Collector for Akka, join host Dan Ivovich to compare notes on garbage collection in actor models. The discussion digs into the similarities and differences of actor-based garbage collection in Erlang and Akka and introduces Dan's research on how to perform garbage collection in a distributed actor system. Topics discussed: Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes Challenges include reasoning about failures like dropped messages and crashed nodes GC balance requires optimization of resource release and CPU load management Immutability helps Erlang GC, but copying data for messages impacts performance Research into distributed actor GC is still ongoing, with opportunities for improvement Fault tolerance in Erlang relies on user implementation rather than low-level guarantees Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research Idempotent messaging is recommended to handle possible duplicates from failures Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases Links mentioned: Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i Scala https://www.scala-lang.org/ Akka Framework https://github.com/akka JVM (Java Virtual Machine) https://www.java.com/en/download/ The BEAM VM https://www.erlang.org/blog/a-brief-beam-primer/ Hadoop Framework https://hadoop.apache.org/ Pony Programming Language https://www.ponylang.io/ SLSA Programming Language https://wcl.cs.rpi.edu/salsa/#:~:text=SALSA%20 Paxos Algorithm https://en.wikipedia.org/wiki/Paxos_(computer_science) Raft library for maintaining a replicated state machine https://github.com/etcd-io/raft Dan's Website https://dplyukhin.github.io/ Dan Plyukhin on Twitter: https://twitter.com/dplyukhin Dan Plyukhin’s YouTube channel: https://m.youtube.com/@dplyukhin UIGC on GitHub https://github.com/dplyukhin/UIGC Manuel's Website https://altenwald.com/ Manuel Rubio on Twitter: https://twitter.com/MRonErlang Special Guests: Dan Plyukhin and Manuel Rubio.…

Elixir Wizards

1
Machine Learning in Elixir vs. Python, SQL, and Matlab with Katelynn Burns & Alexis Carpenter 31:19

לפני 2 years31:19

31:19

In this episode of Elixir Wizards, Katelynn Burns, software engineer at LaunchScout, and Alexis Carpenter, senior data scientist at cars.com, join Host Dan Ivovich to discuss machine learning with Elixir, Python, SQL, and MATLAB. They compare notes on available tools, preprocessing, working with pre-trained models, and training models for specific jobs. The discussion inspires collaboration and learning across communities while revealing the foundational aspects of ML, such as understanding data and asking the right questions to solve problems effectively. Topics discussed: Using pre-trained models in Bumblebee for Elixir projects Training models using Python and SQL The importance of data preprocessing before building models Popular tools used for machine learning in different languages Getting started with ML by picking a personal project topic of interest Resources for ML aspirants, such as online courses, tutorials, and books The potential for Elixir to train more customized models in the future Similarities between ML approaches in different languages Collaboration opportunities across programming communities Choosing the right ML approach for the problem you're trying to solve Productionalizing models like fine-tuned LLM's The need for hands-on practice for learning ML skills Continued maturation of tools like Bumblebee in Elixir Katelynn's upcoming CodeBeam talk on advanced motion tracking Links mentioned in this episode https://launchscout.com/ https://www.cars.com/ Genetic Algorithms in Elixir by Sean Moriarity Machine Learning in Elixir by Sean Moriarity https://github.com/elixir-nx/bumblebee https://github.com/huggingface https://www.docker.com/products/docker-hub/ Programming with MATLAB https://elixirforum.com/ https://pypi.org/project/pyspark/ Machine Learning Course from Stanford School of Engineering Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow by Aurélien Géron Data Science for Business by Foster Provost & Tom Fawcett https://medium.com/@carscomtech https://github.com/k-burns Code Beam America March, 2024 Special Guests: Alexis Carpenter and Katelynn Burns.…

Elixir Wizards

1
Embedded Systems in Elixir vs. C, C++, and Java with Connor Rigby & Taylor Barto 46:30

לפני 2 years46:30

46:30

This week on Elixir Wizards, Connor Rigby, Software Engineer at SmartRent, and Taylor Barto, Lead Embedded Software Engineer at Eaton, join Sundi Myint to compare notes on embedded systems development with Elixir, C, C++, and Java. They discuss using Elixir and the Nerves framework for firmware projects versus more traditional choices like C. The guests ask one another questions and gain valuable insights into challenges, tooling, resources, and more across different embedded ecosystems. In this episode, the guests expand their perspectives and demystify the concept of embedded systems for engineers outside the field. This cross-language exchange of ideas and experiences inspires continued learning and collaboration between embedded software engineers using different programming languages. Topics Discussed: Defining "true embedded": using an operating system vs. bare metal programming Benefits and drawbacks of Elixir, C, C++, and Java for firmware Many embedded systems today use Java as the programming language via Java Native Interface (JNI) to interface with C/C++ code How Elixir expands the toolbox available for firmware projects Testing, tooling, workflows, and debugging across languages Elixir/Nerves features like hot code reloading and testing vs. Java alternatives Learning curves for new languages and frameworks Industry trends around established vs emerging tools Applying functional programming principles like immutability in new domains Scaling firmware updates across large connected networks Continued maturation of Nerves may bring Elixir into consideration for roles where Java is commonly used today Hardening systems for reliability in safety-critical uses Debugging differences between web development and embedded Hiring considerations for niche languages Additional skills needed for embedded engineers, such as technical writing, reading schematics, and writing test instructions Resources and recommendations for getting started with embedded systems Links Mentioned: Nerves: https://github.com/nerves-project/nerves https://nerves-project.org/ AtomVM: https://github.com/atomvm/AtomVM GRiSP: https://github.com/grisp RISC-V: https://github.com/ultraembedded/riscv https://smartrent.com/ https://www.eaton.com/us/en-us.html Zig Programming Language: https://github.com/ziglang Docker: https://github.com/docker Build a Weather Station with Elixir and Nerves by Alexander Koutmos, Bruce A. Tate, Frank Hunleth Build a Binary Clock with Elixir and Nerves by Frank Hunleth and Bruce A. Tate http://esp32.net/ https://www.nordicsemi.com/ Special Guests: Connor Rigby and Taylor Barto.…

Elixir Wizards

1
ECS / Game Development with Elixir vs. Python, JavaScript, React with Dorian Iacobescu & Daniel Luu 41:08

לפני 2 years41:08

41:08

In Episode 4, the Elixir Wizards are joined by Dorian Iacobescu, author of the ECSpanse ECS library for Elixir, and Daniel Luu, founder and CEO of the game development studio AKREW. The guests compare notes on backend game development using ECS, the Entity Component System approach. Akrew is currently building the multiplayer game Galactic Getaway using the Photon Unity networking framework, which employs ECS. They discuss challenges like collections of component types and persistence beyond runtime, building games for various platforms like MacOS, and handling inventory storage in a backend database. Game development is complex and has many technical hurdles, but open communication across different programming communities and game development approaches can foster collaboration, innovation, and continued learning. Topics Discussed in this Episode Dorian explains the ECSpanse ECS library and component-based architecture Dorian took inspiration for ECSpanse from the Rust library Bevy ECS and its component-based API The guests discuss popular game development platforms and languages, including C#, JavaScript, and Godot Owen and Daniel translate ECS concepts to familiar database and backend terminology for devs without game-specific experience ECSpanse uses many tools from the Elixir Erlang toolbox, including GenServers, ETS tables, tasks, queries, and Phoenix LiveView ECS challenges representing inventory collections that broke typical ECS singleton patterns AKREW is developing Galactic Getaway using the Photon Unity framework Relationships between parent and child entities in ECSpanse Persistence, serialization, and replay features to save game state Optimizing assets and code for performance on various devices Links Mentioned https://en.wikipedia.org/wiki/Entity_component_system https://iacobson.medium.com/elixir-for-fun-ecspanse-2852a7993ecd https://hexdocs.pm/ecspanse/Ecspanse.html https://bevyengine.org/learn/book/getting-started/ecs/ https://www.photonengine.com/quantum Add Galactic Getaway to your Steam Wishlist: https://store.steampowered.com/app/2012390/Galactic_Getaway/ https://godotengine.org/ https://unity.com/ https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html https://www.tiktok.com/@galacticgetaway https://docs.rs/bevy_ecs/latest/bevy_ecs/ Special Guests: Daniel Luu and Dorian Iacobescu.…

Elixir Wizards

1
Learning a Language: Elixir vs. JavaScript with Yohana Tesfazgi & Wes Bos 42:14

לפני 2 years42:14

42:14

This week, the Elixir Wizards are joined by Yohana Tesfazgi and Wes Bos to compare notes on the experience of learning Elixir vs. JavaScript as your first programming language. Yohana recently completed an Elixir apprenticeship, and Wes Bos is a renowned JavaScript educator with popular courses for beginner software developers. They discuss a variety of media and resources and how people with different learning styles benefit from video courses, articles, or more hands-on projects. They also discuss the current atmosphere for those looking to transition into an engineering career and how to stick out among the crowd when new to the scene. Topics Discussed in this Episode Pros and cons of learning Elixir as your first programming language Materials and resources for beginners to JavaScript and Elixir Projects and methods for learning Elixir with no prior knowledge Recommendations for sharpening and showcasing skills How to become a standout candidate for potential employers Soft skills like communication translate well from other careers to programming work Learning subsequent languages becomes more intuitive once you learn your first How to decide which library to use for a project How to build an online presence and why it’s important Open-source contributions are a way to learn from the community Ship early and often, just deploying a default Phoenix app teaches deployment skills Attend local meetups and conferences for mentoring and potential job opportunities Links Mentioned https://syntax.fm/ https://fly.io/ https://elixirschool.com/en Syntax.fm: Supper Club × How To Get Your First Dev Job With Stuart Bloxham Quinnwilton.com https://github.com/pallets/flask https://wesbos.com/courses https://beginnerjavascript.com/ Free course: https://javascript30.com/ https://pragmaticstudio.com/ https://elixircasts.io/ https://grox.io/ LiveView Mastery YouTube Channel Contact Yohana: yytesfazgi@gmail.com…

Elixir Wizards

1
HTTP Requests in Elixir vs. JavaScript with Yordis Prieto & Stephen Chudleigh 50:29

לפני 2 years50:29

50:29

In today’s episode, Sundi and Owen are joined by Yordis Prieto and Stephen Chudleigh to compare notes on HTTP requests in Elixir vs. Ruby, JavaScript, Go, and Rust. They cover common pain points when working with APIs, best practices, and lessons that can be learned from other programming languages. Yordis maintains Elixir's popular Tesla HTTP client library and shares insights from building APIs and maintaining open-source projects. Stephen has experience with Rails and JavaScript, and now works primarily in Elixir. They offer perspectives on testing HTTP requests and working with different libraries. While Elixir has matured, there is room for improvement - especially around richer struct parsing from HTTP responses. The discussion highlights ongoing efforts to improve the developer experience for HTTP clients in Elixir and other ecosystems. Topics Discussed in this Episode HTTP is a protocol - but each language has different implementation methods Tesla represents requests as middleware that can be modified before sending Testing HTTP requests can be a challenge due to dependence on outside systems GraphQL, OpenAPI, and JSON API provide clear request/response formats Elixir could improve richer parsing from HTTP into structs Focus on contribution ergonomics lowers barriers for new participants Maintainers emphasize making contributions easy via templates and clear documentation APIs drive adoption of standards for client/server contracts They discuss GraphQL, JSON API, OpenAPI schemas, and other standards that provide clear request/response formats TypeScript brings types to APIs and helps to validate responses Yordis notes that Go and Rust make requests simple via tags for mapping JSON to structs Language collaboration shares strengths from different ecosystems and inspires new libraries and tools for improving the programming experience Links Mentioned Elixir-Tesla Library: https://github.com/elixir-tesla/tesla Yordis on Github: https://github.com/yordis Yordis on Twitter: https://twitter.com/alchemist_ubi Yordis on LinkedIn: https://www.linkedin.com/in/yordisprieto/ Yordis on YouTube: https://www.youtube.com/@alchemistubi Stephen on Twitter: https://twitter.com/stepchud Stephen's projects on consciousness: https://harmonicdevelopment.us Owen suggests: Http.cat HTTParty: https://github.com/jnunemaker/httparty Guardian Library: https://github.com/ueberauth/guardian Axios: https://axios-http.com/ Straw Hat Fetcher: https://github.com/straw-hat-team/nodejs-monorepo/tree/master/packages/%40straw-hat/fetcher Elixir Tesla Wiki: https://github.com/elixir-tesla/tesla/wiki HTTPoison: https://github.com/edgurgel/httpoison Tesla Testing: https://hexdocs.pm/tesla/readme.html#testing Tesla Mock: https://hexdocs.pm/tesla/Tesla.Mock.html Finch: https://hex.pm/packages/finch Mojito: https://github.com/appcues/mojito Erlang Libraries and Frameworks Working Group: https://github.com/erlef/libs-and-frameworks/ and https://erlef.org/wg/libs-and-frameworks Special Guests: Stephen Chudleigh and Yordis Prieto.…

ברוכים הבאים אל Player FM!

Player FM סורק את האינטרנט עבור פודקאסטים באיכות גבוהה בשבילכם כדי שתהנו מהם כרגע. זה יישום הפודקאסט הטוב ביותר והוא עובד על אנדרואיד, iPhone ואינטרנט. הירשמו לסנכרון מנויים במכשירים שונים.

תקשיבו ל-500+ נושאים

79 subscribers

דומה לElixir Wizards

TERRO Ant Killer Bait Stations T300B - Liquid Bait to Eliminate Ants - 12 Count Stations for Effective Indoor Ant Control

Crayola Colored Pencils (36ct), Kids Pencil Set, Back to School Essentials, Must Have Classroom Supplies for Kids, Pre-Sharpened Coloring Book Pencils, 3+

Bounty Quick Size Paper Towels, White, 8 Family Rolls = 20 Regular Rolls (Packaging May Vary)

פודקאסטים ששווה להאזין

Elixir Wizards « » Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin

Topics discussed:

Links mentioned:

Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin

Topics discussed:

Links mentioned:

פודקאסטים ששווה להאזין

ברוכים הבאים אל Player FM!

The Let Them Theory: A Life-Changing Tool That Millions of People Can't Stop Talking About

The Let Them Theory: A Life-Changing Tool That Millions of People Can't Stop Talking About

Minecraft

Mighty Patch™ Original patch from Hero Cosmetics – The #1 Hydrocolloid Acne Pimple Patch for Shrinking Zits and Whiteheads in 1 use; Nighttime Spot Stickers for Face and Skin (36 Count)

The Let Them Theory: A Life-Changing Tool That Millions of People Can't Stop Talking About

דומה לElixir Wizards

מדריך עזר מהיר

Elixir Wizards « »
Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin