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

Elixir Wizards

Player FM - Internet Radio Done Right

79 subscribers

Web Development

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

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

Interrogation Nation - Full Police Interrogations, Serial Killer Docs and True Crime Investigations

1
When Killers Realize It's Over: Raw Police Interrogation Murderer Reaction Compilation 1:22:29

לפני 24 ימים1:22:29

הפעל מאוחר יותר

רשימות

לייק

אהבתי

1:22:29

When Killers Realize It's Over: Raw Police Interrogation Murderer Reaction Compilation Some moments in true crime are unforgettable—none more so than the second a killer realizes it’s over. This episode dives into a chilling compilation of real police interrogations, capturing the exact moment suspects break. From calculated silence to sudden emotional collapse, we explore: The mindset behind their deception The breaking point during questioning The jaw-dropping confessions that followIncluding cases where the accused thought they were untouchable—until undeniable evidence shattered their story. These raw, emotional moments are disturbing, riveting, and revealing. You’ll hear the psychological unraveling firsthand. Content Warning: Contains graphic details of violent crimes, real audio clips, and emotionally intense content. Listener discretion is advised. When Killers Realize It's Over Raw Police Interrogation Reaction Compilation killer interrogations, raw police interrogations, true crime podcast, criminal confessions, when killers break down, interrogation room moments, police interviews, shocking confessions, caught lying, interrogation breakdowns, true crime reactions full police interrogations raw interrogation footage killer confessions suspect breakdown interrogation room reactions real crime footage police interview compilation murder suspect reactions criminal confessions true crime interrogation series serial killer interrogations Hosted on Acast. See acast.com/privacy for more information. Become a supporter of this podcast: https://www.spreaker.com/podcast/interrogation-nation-full-police-interrogations-serial-killer-docs-and-true-crime-investigations--6672917/support .…

לפני שנתיים 42:14

MP3•בית הפרקים

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

198 פרקים

#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

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

Elixir Wizards

79 subscribers

published לפני שנתיים

שתפו

MP3•בית הפרקים

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

198 פרקים

#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
Nix for Elixir Apps with Norbert (NobbZ) Melzer 41:15

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

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

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

לפני 26 ימים48:58

48:58

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

Elixir Wizards

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

לפני 52 weeks59: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.…

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

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