165 episodes

Elixir Wizards is an interview-style podcast for anyone interested in functional programming and the Elixir Programming Language. Hosted by SmartLogic engineers and Elixirists Owen Bickford, Dan Ivovich, and Sundi Myint, this show features in-depth discussions with some of the brightest minds in the industry, discussing training and documentation in Phoenix LiveView, the evolution of programming languages, Erlang VM, and more.
In the current season, we're branching out from Elixir to compare notes with thought leaders and software engineers from programming languages like JavaScript, Ruby on Rails, Go, Scala, Java, and more. Each episode will take a deep dive into a topic from Machine Learning and AI, to ECS and game development, to education and community.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)

Elixir Wizards SmartLogic LLC

    • Technology
    • 4.9 • 21 Ratings

Elixir Wizards is an interview-style podcast for anyone interested in functional programming and the Elixir Programming Language. Hosted by SmartLogic engineers and Elixirists Owen Bickford, Dan Ivovich, and Sundi Myint, this show features in-depth discussions with some of the brightest minds in the industry, discussing training and documentation in Phoenix LiveView, the evolution of programming languages, Erlang VM, and more.
In the current season, we're branching out from Elixir to compare notes with thought leaders and software engineers from programming languages like JavaScript, Ruby on Rails, Go, Scala, Java, and more. Each episode will take a deep dive into a topic from Machine Learning and AI, to ECS and game development, to education and community.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)

    "Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna

    "Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna

    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.

    • 43 min
    "Testing 1, 2, 3" with Joel Meador and Charles Suggs

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

    The Elixir Wizards Podcast is back with Season 12 Office Hours, where we talk with the internal SmartLogic team about the stages of the software development lifecycle. For the season premiere, "Testing 1, 2, 3," Joel Meador and Charles Suggs join us to discuss the nuances of software testing.


    In this episode, we discuss everything from testing philosophies to test driven development (TDD), integration, and end-user testing. Our guests share real-world experiences that highlight the benefits of thorough testing, challenges like test maintenance, and problem-solving for complex production environments.


    Key topics discussed in this episode:


    How to find a balance that's cost-effective and practical while testing
    Balancing test coverage and development speed
    The importance of clear test plans and goals
    So many tests: Unit testing, integration testing, acceptance testing, penetration testing, automated vs. manual testing
    Agile vs. Waterfall methodologies
    Writing readable and maintainable tests
    Testing edge cases and unexpected scenarios
    Testing as a form of documentation and communication
    Advice for developers looking to improve testing practices
    Continuous integration and deployment


    Links mentioned:

    https://smartlogic.io/
    Watch this episode on YouTube! youtu.be/u_nx5AIvSdc
    Bob Martin “Clean Code” videos - “Uncle Bob”: http://cleancoder.com/
    JUnit 5 Testing for Java and the JVM https://junit.org/junit5/
    ExUnit Testing for Elixir https://hexdocs.pm/ex_unit/ExUnit.html
    Code-Level Testing of Smalltalk Applications https://www.cs.ubc.ca/~murphy/st_workshop/28-7.html
    Agile Manifesto https://agilemanifesto.org/
    Old Man Yells at Cloud https://i.kym-cdn.com/entries/icons/original/000/019/304/old.jpg
    TDD: Test Driven Development https://www.agilealliance.org/glossary/tdd/
    Perl Programming Language https://www.perl.org/
    Protractor Test Framework for Angular and AngularJS protractortest.org/#/
    Waterfall Project Management https://business.adobe.com/blog/basics/waterfall
    CodeSync Leveling up at Bleacher Report A cautionary tale - PETER HASTIE
    https://www.youtube.com/watch?v=P4SzZCwB8B4
    Mix ecto.dump https://hexdocs.pm/ecto_sql/Mix.Tasks.Ecto.Dump.html
    Apache JMeter Load Testing in Java https://jmeter.apache.org/
    Pentest Tools Collection - Penetration Testing https://github.com/arch3rPro/PentestTools
    The Road to 2 Million Websocket Connections in Phoenix https://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections
    Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action
    Joel Meador on Tumblr https://joelmeador.tumblr.com/
    Special Guests: Charles Suggs and Joel Meador.

    • 45 min
    Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast)

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

    For the final episode of Elixir Wizards’ Season 11 “Branching Out from Elixir,” we’re featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language.


    This episode covers the origins of creating a language, its influences, and how goals shape the tradeoffs in programming language design. José and Richard share anecdotes from their experiences guiding the evolution of Elixir and Roc. The discussion provides an insightful look at the experimentation and learning involved in crafting new languages.


    Topics discussed in this episode


    What inspires the creation of a new programming language
    Goals and use cases for a programming language
    Influences from Elm, Rust, Haskell, Go, OCaml, and more
    Tradeoffs involved in expressiveness of type systems
    Opportunistic mutation for performance gains in a functional language
    Minimum version selection for dependency resolution
    Build time considerations with type checking and monomorphization
    Design experiments and rolling back features that don’t work out
    History from the first simple interpreter to today's real programming language
    Design considerations around package management and versioning
    Participation in Advent of Code to gain new users and feedback
    Providing performance optimization tools to users in the future
    Tradeoffs involved in picking integer types and arithmetic
    Comparing floats and equality checks on dictionaries
    Using abilities to customize equality for custom types
    Ensuring availability of multiple package versions for incremental upgrades
    Treating major version bumps as separate artifacts
    Roc's focus on single-threaded performance


    Links mentioned in this episode

    Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted
    Roc Programming Language https://www.roc-lang.org/
    Roc Lang on Github https://github.com/roc-lang/roc
    Elm Programming Language https://elm-lang.org/
    Elm in Action by Richard Feldman https://www.manning.com/books/elm-in-action
    Richard Feldman on Github https://github.com/rtfeldman
    Lua Programming Language https://www.lua.org/
    Vimscript Guide https://google.github.io/styleguide/vimscriptfull.xml
    OCaml Programming Language https://ocaml.org/
    Advent of Code https://adventofcode.com/
    Roc Language on Twitter https://twitter.com/roc_lang
    Richard Feldman on Twitter https://twitter.com/rtfeldman
    Roc Zulip Chat https://roc.zulipchat.com
    Clojure Programming Language https://clojure.org/
    Talk: Persistent Data Structures and Managed References by Rich Hickey https://www.youtube.com/watch?v=toD45DtVCFM
    Koka Programming Language https://koka-lang.github.io/koka/doc/index.html
    Flix Programming Language https://flix.dev/
    Clojure Transients https://clojure.org/reference/transients
    Haskell Software Transactional Memory https://wiki.haskell.org/Software_transactional_memory
    Rust Traits https://doc.rust-lang.org/book/ch10-02-traits.html
    CoffeeScript https://coffeescript.org/
    Cargo Package Management https://doc.rust-lang.org/book/ch01-03-hello-cargo.html
    Versioning in Golang https://research.swtch.com/vgo-principles
    Special Guests: José Valim and Richard Feldman.

    • 1 hr 9 min
    Package Management in Elixir vs. JavaScript with Wojtek Mach & Amal Hussein

    Package Management in Elixir vs. JavaScript with Wojtek Mach & Amal Hussein

    Today on Elixir Wizards, Wojtek Mach of HexPM and Amal Hussein, engineering leader and former NPM team member, join Owen Bickford to compare notes on package management in Elixir vs. JavaScript. This lively conversation covers everything from best practices for dependency management to API design, SemVer (semantic versioning), and the dark ages of web development before package managers existed.


    The guests debate philosophical differences between the JavaScript and Elixir communities. They highlight the JavaScript ecosystem's maturity and identify potential areas of improvement, contrasted against Elixir’s emphasis on minimal dependencies. Both guests encourage engineers to publish packages, even small ones, as a learning opportunity.


    Topics discussed in this episode:


    Leveraging community packages rather than reinventing the wheel
    Vetting packages carefully before adopting them as dependencies
    Evaluating security, performance, and bundle size when assessing packages
    Managing transitive dependencies pulled in by packages
    Why semantic versioning is difficult to consistently enforce
    Designing APIs with extensibility and backward compatibility in mind
    Using tools like deprecations to avoid breaking changes in new releases
    JavaScript’s preference for code reuse over minimization
    The Elixir community’s minimal dependencies and avoidance of tech debt
    Challenges in early package management, such as global dependency
    Learning from tools like Ruby Gems and Bundler to improve experience
    How log files provide visibility into dependency management actions
    How lock files pin dependency versions for consistency
    Publishing packages democratizes access and provides learning opportunities
    Linting to enforce standards and prevent certain bugs
    Primitive-focused packages provide flexibility over highly opinionated ones
    Suggestions for improving documentation and guides
    Benefits of collaboration between programming language communities


    Links mentioned in this episode:

    Node.js https://github.com/nodejs
    npm JavaScript Package Manager  https://github.com/npm
    JS Party Podcast https://changelog.com/jsparty
    Dashbit https://dashbit.co/
    HexPM Package Manager for Erlang https://hex.pm/
    HTTP Client for Elixir https://github.com/wojtekmach/req
    Ecto Database-Wrapper for Elixir https://github.com/elixir-ecto (Not an ORM)
    XState Actor-Based State Management for JavaScript https://xstate.js.org/docs/
    Supply Chain Protection for JavaScript, Python, and Go  https://socket.dev/
    MixAudit https://github.com/mirego/mix_audit
    NimbleTOTP Library for 2FA https://hexdocs.pm/nimble_totp/NimbleTOTP.html
    Microsoft Azure https://github.com/Azure
    Patch Package https://www.npmjs.com/package/patch-package
    Ruby Bundler to manage Gem dependencies https://github.com/rubygems/bundler
    npm-shrinkwrap https://docs.npmjs.com/cli/v10/commands/npm-shrinkwrap
    SemVer Semantic Versioner for NPM https://www.npmjs.com/package/semver
    Spec-ulation Keynote - Rich Hickey https://www.youtube.com/watch?v=oyLBGkS5ICk
    Amal’s favorite Linter https://eslint.org/
    Elixir Mint Functional HTTP Client for Elixir https://github.com/elixir-mint
    Tailwind Open Source CSS Framework https://tailwindcss.com/
    WebauthnComponents https://hex.pm/packages/webauthn_components
    Special Guests: Amal Hussein and Wojtek Mach.

    • 54 min
    Communities in Tech with Camille Clayton & Scott Tolinski

    Communities in Tech with Camille Clayton & Scott Tolinski

    Today on Elixir Wizards, Camille Clayton, Director of Women Who Code DC, and Scott Tolinski, Co-Host of the Syntax Podcast and Creator of Level Up Tutorials, join hosts Sundi Myint and Owen Bickford to discuss tech community spaces online and IRL.


    They lay out the blueprint and best practices for fostering an inclusive environment where newcomers feel comfortable and welcome to join the discussion – whether it’s an online forum, YouTube comment sections, social media platform, local meetup, or conference.


    Topics discussed in this episode:


    Leaving a space open so newcomers feel empowered to join
    Celebrating small wins to maintain excitement and build confidence
    Why consistency is key to building a community with longevity
    Creating and enforcing a code of conduct to define expectations
    Finding respectful resolutions for addressing issues or complaints
    The importance of amplifying underrepresented voices in tech
    Creating content for all skill levels and adapting to a wider audience
    How remote meetups broaden the possibilities for attendance and connection
    Finding the right fit for mentorship
    Delegation to strengthen community members’ sense of ownership
    Navigating the new normal of local, in-person gatherings post-pandemic


    Links mentioned in this episode:

    https://www.womenwhocode.com/network/dc
    https://syntax.fm/
    https://levelup.video/
    https://devopsdays.org/
    https://github.com/sveltejs
    https://github.com/womenwhocodedc
    https://twitter.com/womenwhocode
    https://www.remoteworkcalc.com/
    https://twitter.com/WomenWhoCodeDC
    https://www.meetup.com/dc-elixir/
    Special Guests: Camille Clayton and Scott Tolinski.

    • 48 min
    Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler

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

    In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure.


    In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads.


    They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project.


    Topics discussed in this episode:


    Difference between actor model and shared memory concurrency
    Isolation of actor state and communication via message passing
    BEAM VM design for high concurrency via lightweight processes
    GenServers as common abstraction for building stateful actors
    GenServer callbacks for message handling and state updates
    Agents as similar process abstraction to GenServers
    Shared state utilities like ETS for inter-process communication
    Global Interpreter Lock in older Ruby VMs
    Ractors as initial actor implementation in Ruby mapping to threads
    Planned improvements to Ruby concurrency in 3.3
    Akka implementation of actor model on JVM using thread scheduling
    Limitations of shared memory concurrency on JVM
    Project Loom bringing lightweight processes to JVM
    Building GenServer behavior in Ruby using metaprogramming
    CSP model of communication using channels in Clojure
    Differences between BEAM scheduler and thread-based VMs
    Comparing Elixir to academic languages like Haskell
    Remote and theScore are hiring!


    Links mentioned in this episode:

    theScore is hiring! https://www.thescore.com/
    Remote is also hiring! https://remote.com/
    Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji
    Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022
    Clojure Programming Language https://clojure.org/
    Akka https://akka.io/
    Go Programming Language https://github.com/golang/go
    Proto Actor for Golang https://proto.actor/
    RabbitMQ Open-Source Message Broker Software  https://github.com/rabbitmq
    JVM Project Loom https://github.com/openjdk/loom
    Ractor for Ruby  https://docs.ruby-lang.org/en/master/ractor_md.html
    Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher
    Seven Languages in Seven Weeks by Bruce A. Tate
    GenServer https://hexdocs.pm/elixir/1.12/GenServer.html
    ets https://www.erlang.org/doc/man/ets.html
    Elixir in Action by Saša Jurić
    Redis https://github.com/redis/redis
    Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski
    Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users
    Xiang's website https://xiangji.me/
    Feeling Good: The New Mood Therapy by David D. Burns
    Special Guests: Nathan Hessler and Xiang Ji.

    • 47 min

Customer Reviews

4.9 out of 5
21 Ratings

21 Ratings

SunsetKnight ,

Excellent!

I’ve been listening to Elixir Wizards for awhile now. It’s my one stop for great elixir content. They are always bringing something fresh to the table and I love how they interview members of the community!

Amos King ,

A fun podcast about Elixir and their ecosystem

I’ve been a guest a few times, and love working with the Wizards. They have a great, laid back interview process, and I always look forward to listening to their episodes.

DanIvovich ,

A Unique Look at Elixir

A different and worthwhile look at Elixir that brings a unique show to the community. Worth every minute I spend listening.

Top Podcasts In Technology

Lex Fridman Podcast
Lex Fridman
All-In with Chamath, Jason, Sacks & Friedberg
All-In Podcast, LLC
No Priors: Artificial Intelligence | Machine Learning | Technology | Startups
Conviction | Pod People
BG2Pod with Brad Gerstner and Bill Gurley
BG2Pod
Acquired
Ben Gilbert and David Rosenthal
Hard Fork
The New York Times

You Might Also Like

Thinking Elixir Podcast
ThinkingElixir.com
Beam Radio
Lars Wikman
Elixir Mix
Charles M Wood
Elixir Outlaws
Elixir Outlaws
The Changelog: Software Development, Open Source
Changelog Media
Software Unscripted
Software Unscripted