Elixir Wizards

Elixir Wizards

By SmartLogic LLCTechnologyEducationHow To
Download on the App Store

Elixir Wizards episodes

  • HTTP Requests in Elixir vs. JavaScript with Yordis Prieto & Stephen Chudleigh

    In today’s episode, Sundi and Owen are joined by Yordis Prieto and Stephen Chudleigh to compare notes on HTTP requests in Elixir vs. Ruby, JavaScript, Go, and Rust. They cover common pain points when working with APIs, best practices, and lessons that can be learned from other programming languages.

    Yordis maintains Elixir's popular Tesla HTTP client library and shares insights from building APIs and maintaining open-source projects. Stephen has experience with Rails and JavaScript, and now works primarily in Elixir. They offer perspectives on testing HTTP requests and working with different libraries.

    While Elixir has matured, there is room for improvement - especially around richer struct parsing from HTTP responses. The discussion highlights ongoing efforts to improve the developer experience for HTTP clients in Elixir and other ecosystems.

    Topics Discussed in this Episode
    • HTTP is a protocol - but each language has different implementation methods
    • Tesla represents requests as middleware that can be modified before sending
    • Testing HTTP requests can be a challenge due to dependence on outside systems
    • GraphQL, OpenAPI, and JSON API provide clear request/response formats
    • Elixir could improve richer parsing from HTTP into structs
    • Focus on contribution ergonomics lowers barriers for new participants
    • Maintainers emphasize making contributions easy via templates and clear documentation
    • APIs drive adoption of standards for client/server contracts
    • They discuss GraphQL, JSON API, OpenAPI schemas, and other standards that provide clear request/response formats
    • TypeScript brings types to APIs and helps to validate responses
    • Yordis notes that Go and Rust make requests simple via tags for mapping JSON to structs
    • Language collaboration shares strengths from different ecosystems and inspires new libraries and tools for improving the programming experience
      • Links Mentioned

      Elixir-Tesla Library: https://github.com/elixir-tesla/tesla

      Yordis on Github: https://github.com/yordis
      Yordis on Twitter: https://twitter.com/alchemist_ubi
      Yordis on LinkedIn: https://www.linkedin.com/in/yordisprieto/
      Yordis on YouTube: https://www.youtube.com/@alchemistubi
      Stephen on Twitter: https://twitter.com/stepchud
      Stephen's projects on consciousness: https://harmonicdevelopment.us
      Owen suggests: Http.cat
      HTTParty: https://github.com/jnunemaker/httparty
      Guardian Library: https://github.com/ueberauth/guardian
      Axios: https://axios-http.com/
      Straw Hat Fetcher: https://github.com/straw-hat-team/nodejs-monorepo/tree/master/packages/%40straw-hat/fetcher
      Elixir Tesla Wiki: https://github.com/elixir-tesla/tesla/wiki
      HTTPoison: https://github.com/edgurgel/httpoison
      Tesla Testing: https://hexdocs.pm/tesla/readme.html#testing
      Tesla Mock: https://hexdocs.pm/tesla/Tesla.Mock.html
      Finch: https://hex.pm/packages/finch
      Mojito: https://github.com/appcues/mojito
      Erlang Libraries and Frameworks Working Group: https://github.com/erlef/libs-and-frameworks/ and https://erlef.org/wg/libs-and-frameworks

      Special Guests: Stephen Chudleigh and Yordis Prieto.

      51 min
    • Season 11 Kickoff: The Hosts Discuss Branching Out from Elixir to Compare Notes

      Hosts Dan Ivovich, Owen Bickford, and Sundi Myint kick off the 11th season of the Elixir Wizards podcast. This season’s theme is “Branching Out from Elixir,” which expands the conversation to compare notes with experts from other communities; they discuss their experiences with other languages like JavaScript, PHP, Python, Ruby, C#, Go, and Dart before and after learning Elixir.

      This season's conversations will illuminate how problems are solved in different languages vs. Elixir; upcoming episode topics teased include education, data processing, deployment strategies, and garbage collection; the hosts express excitement for conversations analyzing similarities and differences between communities.

      Topics Discussed in this Episode
      • Season 11 branches out from Elixir to compare notes with other programming communities
      • Sundi, Owen, and Dan introduce the season theme and their interest in exploring these conversations
      • The hosts compare their experiences with PHP, JavaScript, Python, Ruby, C#, Go, Dart and Elixir
      • The Wizards compare and contrast differences in their personal experience building similar things with different languages
      • Dan dreams in Ruby and uses it for quick prototypes
      • Comparing problem-solving approaches across languages will reframe perspectives
      • Upcoming episodes explore data processing workflows, machine learning, and game development
      • Pop Quiz: Who's that Pokémon... or language, or framework?
        • Links Mentioned

        https://smartlogic.io/

        https://codepen.io/
        https://i.redd.it/0lg7979qtr511.jpg

        33 min
      • José Valim, Guillaume Duboc, and Giuseppe Castagna on the Future of Types in Elixir

        It’s the Season 10 finale of the Elixir Wizards podcast! José Valim, Guillaume Duboc, and Giuseppe Castagna join Wizards Owen Bickford and Dan Ivovich to dive into the prospect of types in the Elixir programming language! They break down their research on set-theoretical typing and highlight their goal of creating a type system that supports as many Elixir idioms as possible while balancing simplicity and pragmatism.

        José, Guillaume, and Giuseppe talk about what initially sparked this project, the challenges in bringing types to Elixir, and the benefits that the Elixir community can expect from this exciting work. Guillaume's formalization and Giuseppe's "cutting-edge research" balance José's pragmatism and "Guardian of Orthodoxy" role. Decades of theory meet the needs of a living language, with open challenges like multi-process typing ahead. They come together with a shared joy of problem-solving that will accelerate Elixir's continued growth.

        Key Topics Discussed in this Episode:
        • Adding type safety to Elixir through set theoretical typing
        • How the team chose a type system that supports as many Elixir idioms as possible
        • Balancing simplicity and pragmatism in type system design
        • Addressing challenges like typing maps, pattern matching, and guards
        • The tradeoffs between Dialyzer and making types part of the core language
        • Advantages of typing for catching bugs, documentation, and tooling
        • The differences between typing in the Gleam programming language vs. Elixir
        • The possibility of type inference in a set-theoretic type system
        • The history and development of set-theoretic types over 20 years
        • Gradual typing techniques for integrating typed and untyped code
        • How José and Giuseppe initially connected through research papers
        • Using types as a form of "mechanized documentation"
        • The risks and tradeoffs of choosing syntax
        • Cheers to another decade of Elixir!
        • A big thanks to this season’s guests and all the listeners!
          • Links and Resources Mentioned in this Episode:

          Bringing Types to Elixir | Guillaume Duboc & Giuseppe Castagna | ElixirConf EU 2023

          Keynote: Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022
          OCaml industrial-strength functional programming https://ocaml.org/
          ℂDuce: a language for transformation of XML documents http://www.cduce.org/
          Ballerina coding language https://ballerina.io/
          Luau coding language https://luau-lang.org/
          Gleam type language https://gleam.run/
          "The Design Principles of the Elixir Type System" by G. Castagna, G. Duboc, and J. Valim
          "A Gradual Type System for Elixir" by M. Cassola, A. Talagorria, A. Pardo, and M. Viera
          "Programming with union, intersection, and negation types", by Giuseppe Castagna
          "Covariance and Contravariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)" by Giuseppe Castagna
          "A reckless introduction to Hindley-Milner type inference"

          Special Guests: Giuseppe Castagna, Guillaume Duboc, and José Valim.

          49 min
        • Chris McCord and Jason Stiebs on the Future of Phoenix

          Phoenix core team members Chris McCord and Jason Stiebs join Elixir Wizards Sundi Myint and Owen Bickford the growth of Phoenix and LiveView, the latest updates, and what they're excited to see in the future. They express excitement for the possibilities of machine learning, AI, and distributed systems and how these emerging technologies will enhance the user experience of Elixir and LiveView applications in the next decade.

          Key Topics Discussed in this Episode:

          • How community contributions and feedback help improve Phoenix LiveView
          • The addition of function components, declarative assigns, HEEx, and streams
          • Why Ecto changesets should be used as "fire and forget" data structures
          • Excitement about machine learning and AI with libraries like NX
          • The possibility of distributed systems and actors in the future
          • Verifying and solving issues in the Phoenix and LiveView issue trackers
          • Why marketing plays a part in the adoption and mindshare of Phoenix
          • How streams provide a primitive for arbitrarily large dynamic lists
          • Elixir VM's ability to scale to millions of connections
          • A creative use of form inputs for associations with dynamic children

            • Links Mentioned in this Episode:

            Fly Site https://fly.io/

            Keynote: The Road To LiveView 1.0 by Chris McCord | ElixirConf EU 2023
            Keynote: I Was Wrong About LiveView by Jason Stiebs | ElixirConf 2022
            Phoenix Site https://www.phoenixframework.org/
            Phoenix Github https://github.com/phoenixframework
            Two-Story, 10-Room Purple Martin House
            Blog: The Road to 2 Million Websocket Connections in Phoenix
            Raxx Elixir Webserver Interface https://hexdocs.pm/raxx/0.4.1/readme.html
            Livebook Site https://livebook.dev/
            Sundi’s 6’x 6’ Phoenix painting
            Surface on Hex https://hex.pm/packages/surface
            Axon Deep Learning Framework https://hexdocs.pm/axon/Axon.html
            Nx Numerical Elixir https://hexdocs.pm/nx/intro-to-nx.html
            Phoenix PubSub https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html
            Jason Stiebs on Twitter https://twitter.com/peregrine
            Jason Stiebs on Mastodon https://merveilles.town/@peregrine

            Special Guests: Chris McCord and Jason Stiebs.

            59 min
          • Sean Moriarity on the Future of Machine Learning with Elixir

            Sean Moriarity, author of Genetic Algorithms in Elixir and creator of the Axon Library, joins Elixir Wizards Sundi Myint and Bilal Hankins to discuss Elixir’s role in the future of machine learning and AI. He explains the difference between artificial intelligence, chat models, machine learning, deep learning systems, and neural networks.

            Large language models have great potential for code generation, education tools, streamlining workflow, and more. Deployment, development experience, and real-time processing make Elixir an ideal programming language for creating and improving machine learning tools.

            Key Topics Discussed in this Episode:

            • The difference between machine learning and artificial intelligence
            • How Axon builds on top of the Nx library for deep learning in Elixir
            • Why logic cannot fully define characteristics that identify golden retrievers
            • How Google Translate uses machine learning with a unified language model
            • The difficulties in translating concepts with no direct counterpart between languages
            • Data cleaning and labeling challenges
            • How Sean's interest in sports betting led to exploring machine learning
            • Why Sean's NBA betting model recommended betting $0 to maximize profit
            • Getting started with machine learning and Elixir projects
            • Attention mechanisms in neural networks
            • Bias and exceptions in machine translation models
            • How hummus preference was used to determine Sundi's Hogwarts house
            • Sean's work on a LiveView interface for ChatGPT
            • Why Elixir's deployment story, development experience, and real-time processing are good fits for machine learning applications

              • Links Mentioned:

              Genetic Algorithms in Elixir by Sean Moriarity: https://pragprog.com/titles/smgaelixir/genetic-algorithms-in-elixir/

              Axon Deep Learning in Elixir: https://seanmoriarity.com/2021/04/08/axon-deep-learning-in-elixir/
              Nx Axon: https://github.com/elixir-nx/axon
              Sean’s Twitter: https://twitter.com/sean_moriarity
              Weston the Golden’s IG: https://www.instagram.com/westonthegolden_/
              Sean’s Github: https://github.com/seanmor5
              Bumblebee: https://github.com/elixir-nx/bumblebee
              Sal Khan’s TedTalk about AI in Education: https://www.ted.com/talks/sal_khan_how_ai_could_save_not_destroy_education/c
              Publicly Available Datasets/Intro to Machine Learning: https://www.kaggle.com/
              Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023 https://ti.to/empex-ny/empex-nyc-2023

              Special Guest: Sean Moriarity.

              48 min
            • Hugo Baraúna & Lucas San Roman on the Future of the Elixir Community

              In this episode of the Elixir Wizards podcast, hosts Sundi Myint and Owen Bickford are joined by Hugo Baraúna, founder at Elixir Radar, and Lucas San Roman, senior software engineer at Felt. We dive into the future of the Elixir community, how we stay connected, and the remarkable culture that has developed over the past decade.

              Key highlights in this episode:

              • The Elixir community's warm and inviting atmosphere
              • Commitment to long-term stability and innovation in the Elixir community
              • How projects like Nerves, Phoenix LiveView, and Livebook expand Elixir's capabilities
              • Global connections and support among Elixirists via Slack and Discord
              • The Elixir Radar newsletter provides up-to-date Elixir news and community developments
              • Getting “nerd sniped” by the community
              • Hugo Baraúna's motivation behind Elixir Radar and its impact on the tech industry
              • Networking opportunities and relationship-building within the community
              • Lucas San Roman's commitment to giving back with the Sourcerer Library
              • Plans for more advanced collaboration in Livebook with the new Teams feature
              • The potential introduction of a type system in Elixir

                • Links mentioned in this episode:

                Elixir Radar: https://elixir-radar.com/

                Felt: https://felt.com/
                Ruby Weekly: https://rubyweekly.com/
                The Elixir Discord Server: https://discord.com/invite/elixir
                Code Fragment: https://hexdocs.pm/elixir/Code.Fragment.html
                The Sourcerer Library: https://github.com/doorgan/sourceror
                Livebook: https://livebook.dev/
                Lucas’ Blog: https://dorgan.ar/
                Hugo’s Twitter: https://twitter.com/hugobarauna
                Elixir Radar on Twitter: https://twitter.com/elixir_radar
                Livebook on Twitter: https://twitter.com/livebookdev
                Lucas’ Twitter https://twitter.com/dorgan_
                Guillaume Duboc Bringing Types to Elixir at ElixirConf EU 2023
                Lucas on GitHub: https://github.com/doorgan
                Rooster Fighter on Easter Island
                Rooster Fighter at Iguazu Falls in Argentina

                Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023

                Special Guests: Hugo Baraúna and Lucas San Roman.

                51 min
              • José Valim on the Future of the Elixir Ecosystem

                Today on Elixir Wizards, José Valim, creator of the Elixir programming language, joins hosts Sundi Myint and Owen Bickford to discuss the future of Elixir, upcoming features, changes to the language and ecosystem, and the potential for a type system.

                José discusses how Elixir’s extensibility allows the ecosystem to grow with new tools and libraries, all while requiring few languages to the core language.

                Key Takeaways:

                • The origin of the famous rainbow heart combo
                • José’s hands-off approach to planning the ecosystem which allows community contribution without reliance on the core team
                • The success and growth of the Elixir community
                • Lessons learned in the first ten years of the language
                • The evolution of Elixir's documentation and the role of Livebook in creating more interactive and engaging learning experiences
                • The potential for Elixir Nx to make numerical computation, machine learning, and data science more accessible to Elixir developers
                • Potential implementation of a gradual type system and the importance of backwards compatibility
                • The role of the Elixir community in shaping the language's development and ecosystem, including the importance of open-source contributions
                • Whether we’ll see Elixir 2.0 in the next decade

                  • Links mentioned in this episode:

                  Josė Valim Keynote ElixirConf EU Bringing Elixir to Life

                  Dashbit - https://dashbit.co/
                  Elixir programming language: https://elixir-lang.org/
                  ElixirConf: https://elixirconf.com/
                  ElixirForum: https://elixirforum.com/
                  Elixir's Logger library: https://hexdocs.pm/logger/Logger.html
                  José's Twitter: https://twitter.com/josevalim
                  ElixirLS (Elixir Language Server) https://github.com/elixir-lsp/elixir-ls
                  Mermaid Charts in Livebook - https://news.livebook.dev/date/2022/1
                  IEx - https://hexdocs.pm/iex/1.14/IEx.html
                  Numerical Elixir - Nx: https://hexdocs.pm/nx/getting-started.html
                  Nerves: https://hexdocs.pm/nerves/getting-started.html
                  Membrane: https://hexdocs.pm/membrane/getting-started.html
                  Dialyxir: https://hexdocs.pm/dialyxir/readme.html
                  LiveBook: https://hexdocs.pm/livebook/getting-started.html
                  Bumblebee: https://github.com/elixir-nx/bumblebee

                  Special Guest: José Valim.

                  44 min
                • Saša Jurić on The Future of Training & Education in Elixir

                  Today on Elixir Wizards, Sundi Myint and Owen Bickford are joined by Saša Jurić, distinguished developer, mentor, and author of Elixir in Action. They discuss the future of training and education in Elixir, challenges faced by new Elixir developers, Phoenix generators, peer mentorship, the emergence of types, and when it’s time to close the umbrella.

                  Key Takeaways:

                  • The functional programming paradigm, the actor model, and concurrency
                  • Adapting to the Elixir syntax and tooling
                  • The role of community, mentorship, and continuous learning in Elixir education
                  • The pros and cons of Phoenix generators for Elixir development
                  • Customizing templates in the Phoenix priv directory to better suit individual needs
                  • The importance of understanding and adapting generated code for maintainability and proper abstractions
                  • Importance of having a clear separation between core and interface
                  • Adapting to different opinions and preferences within a development team
                  • Refactoring and restructuring code to improve quality and reduce complexity
                  • Static typing for better documentation and the limitations of dynamic code
                  • Umbrella apps vs. mix configuration and how to avoid complexity

                    • Links Mentioned in this Episode:

                    Enter to win a copy of Elixir in Action: https://smr.tl/2023bookgiveaway

                    Elixir in Action by Saša Jurić https://www.manning.com/books/elixir-in-action

                    35% discount code for book on manning.com: podexwizards20

                    Saša’s Website/Blog TheErlangelist.com

                    Towards Maintainable Elixir - Saša Jurić's Medium Blog Article Series
                    Boundary: Managing cross-module dependencies in Elixir projects
                    Site Encrypt: Integrated Certification via Let's Encrypt for Elixir-powered sites

                    Authentication Generator in Phoenix: https://hexdocs.pm/phoenix/mix_phx_gen_auth.html

                    Ecto query generator for Elixir https://hexdocs.pm/ecto/Ecto.html
                    GraphQL: Query language for APIs https://graphql.org/
                    Dialyxir: https://hexdocs.pm/dialyxir/readme.html
                    Nx (Numerical Elixir) GitHub Repository: https://github.com/elixir-nx/nx
                    ElixirLS (Elixir Language Server) GitHub Repository: https://github.com/elixir-lsp/elixir-ls

                    Special Guest: Saša Jurić.

                    47 min
                  • Mat Trudel on the Future of Phoenix and Web Transports

                    In this episode of Elixir Wizards, Owen and Dan talk to Mat Trudel, Phoenix contributor and creator of the Bandit Web Server, about the future of Phoenix, web transports, and HTTP/3. Mat explains the challenges and benefits of implementing HTTP/3 support in Phoenix.

                    Mat provides in-depth insights into the evolution of web protocols and encourages developers to continue pushing the boundaries of web development and to contribute to the growth of the open-source community.

                    Main topics discussed in this episode:

                    • The evolution of web protocols and how HTTP/3 is changing the landscape
                    • The challenges and benefits of implementing HTTP/3 support in Phoenix
                    • How a home AC project revealed a gap in web server testing tools and inspired Bandit
                    • how web transports like Cowboy and Ranch are used to build scalable web servers
                    • WebSock for multiplexing data over a single WebSocket connection
                    • Mat’s philosophy on naming projects and his passion for malapropisms
                    • The Bandit project and how it can help developers better understand web protocols
                    • Autobahn, a testing suite for WebSocket protocol specification conformance
                    • The importance of community involvement in open-source projects
                    • Encouragement for more people to use Bandit and report bugs

                      • Links Mentioned:

                      SmartLogic is Hiring: https://smartlogic.io/about/jobs

                      PagerDuty: https://www.pagerduty.com
                      Phoenix Framework: https://www.phoenixframework.org/
                      Cowboy: https://ninenines.eu/docs/en/cowboy/2.9/guide/introduction/
                      Ranch: https://github.com/ninenines/ranch
                      Bandit - https://hexdocs.pm/bandit/Bandit.html
                      Autobahn: https://github.com/crossbario/autobahn-testsuite
                      HTTP Cats: https://http.cat/
                      Mat Trudel at Empex 2022 A Funny Thing Happened On The Way To The Phoenix
                      Thousand Island - https://hexdocs.pm/thousand_island/ThousandIsland.html

                      Special Guest: Mat Trudel.

                      49 min
                    • Mike Waud and Tony Winn on the Future of Elixir on the Grid

                      Elixir Wizards Owen Bickford and Dan Ivovich are joined by Mike Waud, Senior Software Engineer at SparkMeter, and Tony Winn, Lead Software Architect at Generac, to discuss the future of the BEAM in the electric grid, how their companies use Elixir, and the challenges they face in implementing cutting-edge technologies in an environment with a mix of old and new systems.

                      Both guests have backgrounds in various programming languages before turning to Elixir for its functional programming capabilities, concurrency, and reliability. Elixir's portability allows it to be used in various environments, from cloud-based systems to more conservative organizations that prefer running software off the cloud.

                      Key topics discussed in this episode:

                      • Technology sophistication varies across different regions and industries

                      • BEAM's reliability, concurrency, and scaling in electric grid systems
                      • Using Elixir for caching, telemetry, and managing traffic spikes
                      • Elixir fits well for devices due to its fault tolerance and supervision trees
                      • Observability with telemetry hooks for understanding system performance
                      • Traffic patterns in the grid space are often dictated by weather and human activity, requiring efficient handling
                      • The balance between using Elixir/BEAM and other tools depending on use case
                      • Using Elixir tools like Broadway to work with event queues and Nebulex for distributed caching
                      • The future of the electric grid and its evolution over the next 10 years, including a shift towards more distributed energy generation
                      • Global lessons about grid management, solar penetration, regulations, and energy storage
                      • Prioritizing data in IoT systems and processing data at the edge of the network
                      • Gratitude for open-source contributors in the Elixir community

                      Links in this episode:

                      SparkMeter: https://www.sparkmeter.io/

                      Generac: https://www.generac.com/
                      SmartLogic - https://smartlogic.io/jobs
                      Gary Bernhardt's talk on functional core and imperative shell: https://www.destroyallsoftware.com/talks/boundaries
                      Joe Armstrong's Erlang book: https://pragprog.com/titles/jaerlang/programming-erlang/
                      The Nerves podcast and documentation: https://nerves-project.org/

                      Special Guests: Mike Waud and Tony Winn.

                      43 min

                    About Elixir Wizards

                    From the publisher's feed

                    Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software…