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.

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

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.

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.

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/