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.

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.

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.

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.

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: [email protected]
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.

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

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.

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.

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.

To kick off Elixir Wizards Season 13, The Creator's Lab, we're joined by Zach Daniel, the creator of Igniter and the Ash framework. Zach joins hosts Owen Bickford and Charles Suggs to discuss the mechanics and aspirations of his latest brainchild, Igniter—a code generation and project patching framework designed to revolutionize the Elixir development experience.

Igniter isn’t just about generating code; it’s about generating smarter code. By leveraging tools like Sourcerer and Rewrite, Igniter allows developers to modify source code and batch updates by directly interacting with Elixir's AST instead of regex patching. This approach streamlines new project setup and package installations and enhances overall workflow.

They also discuss the strategic implications of Igniter for the broader Elixir community. Zach hopes Igniter will foster a more interconnected and efficient ecosystem that attracts new developers to Elixir and caters to the evolving needs of seasoned Elixir engineers.

Topics discussed in this episode:

• Advanced package installation and code generation improve the developer experience
• Scripting and staging techniques streamline project updates
• Innovative methods for smoother installation processes in Elixir packages
• High-level tools apply direct patches to source code
• Progressive feature additions simplify the mix phx.new experience
• Chaining installers and composing tasks for more efficient project setup
• Continuous improvement in developer experiences to boost Elixir adoption
• Encourage listeners to collaborate by sharing code generation patterns
• Introduction of a new mix task aimed at removing the "unless" keyword in preparation for Elixir 1.18
• You can learn more in the upcoming book "Building Web Applications with Ash Framework" by Zach and Rebecca

Links mentioned:

https://smartlogic.io/
https://alembic.com.au/blog/igniter-rethinking-code-generation-with-project-patching
https://hexdocs.pm/igniter/readme.html
https://github.com/ash-project/igniter
https://www.zachdaniel.dev/p/serialization-is-the-secret
https://www.zachdaniel.dev/p/welcome-to-my-substack
https://ash-hq.org/
https://hexdocs.pm/sourceror/readme.html
https://smartlogic.io/podcast/elixir-wizards/s10-e09-hugo-lucas-future-of-elixir-community/
https://github.com/hrzndhrn/rewrite
https://github.com/zachdaniel
https://github.com/liveshowy/webauthn_components
https://hexdocs.pm/elixir/Regex.html
https://github.com/msaraiva/vscode-surface
https://github.com/swoosh/swoosh
https://github.com/erlef/oidcc
https://alembic.com.au/
https://www.zachdaniel.dev/

Special Guest: Zach Daniel.

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