Avsnitt

  • 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/roclang
    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/Softwaretransactional_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.

  • 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/mixaudit
    NimbleTOTP Library for 2FA https://hexdocs.pm/nimbletotp/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.

  • Saknas det avsnitt?

    Klicka här för att uppdatera flödet manuellt.

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

  • 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 (https://xiangji.me/2023/12/18/comparing-the-actor-model-and-csp-with-elixir-and-clojure/) Blog Post by Xiang Ji
    Comparing the Actor model & CSP concurrency with Elixir & Clojure (https://www.youtube.com/watch?v=lIQCQKPRNCI) 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 (https://pragprog.com/titles/pb7con/seven-concurrency-models-in-seven-weeks/)by Paul Butcher
    Seven Languages in Seven Weeks (https://pragprog.com/titles/btlang/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 (https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/) by Saša Jurić
    Redis https://github.com/redis/redis
    Designing for Scalability with Erlang/OTP (https://www.oreilly.com/library/view/designing-for-scalability/9781449361556/) by Francesco Cesarini & Steve Vinoski
    Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users (https://discord.com/blog/using-rust-to-scale-elixir-for-11-million-concurrent-users)
    Xiang's website https://xiangji.me/
    Feeling Good: The New Mood Therapy (https://www.thriftbooks.com/w/feeling-good-the-new-mood-therapy-by-david-d-burns/250046/?resultid=7691fb71-d8f9-4435-a7a3-db3441d2272b#edition=2377541&idiq=3913925) by David D. Burns Special Guests: Nathan Hessler and Xiang Ji.

  • In this episode of Elixir Wizards, hosts Owen and Dan are joined by René Föhring, creator of Credo for Elixir, and Marc-André LaFortune, head maintainer of the RuboCop AST library for Ruby. They compare static code analysis in Ruby versus Elixir.
    The conversation explores the intricacies and challenges inherent in static code analysis across object-oriented and functional programming paradigms, highlighting the unique characteristics of both Ruby and Elixir. Key topics of discussion include the ways these tools can enhance coding styles and empower developers, the delicate balance between providing guidance and enforcing rules, and the evolving future of code analysis in these languages.
    Topics discussed in this episode:
    The differences and applications between static and dynamic analysis
    How Credo aims to offer flexible and educational guidance for Elixir developers
    The complexities of method identification in Ruby and its impact on static analysis
    Challenges posed by macros and dynamic code modification during compilation in Elixir
    Reducing false positives in code analysis tools to minimize developer frustration
    Promoting uniform coding practices through analysis tools
    The significance of using analysis tools with clear, specific objectives
    How coding standards can refine and improve coding styles over time
    Building analysis tools and checks through an understanding of Abstract Syntax Trees (ASTs)
    Potential advancements in the analysis of Phoenix templates and HTML in Elixir
    Contrasting approaches to managing code and comments in Elixir and Ruby ASTs
    The fine line between providing helpful guidance and imposing stylistic preferences
    Heuristics in static analysis highlight inconsistencies without mandating style
    The potential for more straightforward pattern matching in ASTs with future updates
    The importance of a gradual implementation of tool updates to maintain backward compatibility
    Creating tools that support and empower developers, rather than hinder them
    How static analysis contributes to cleaner, more maintainable codebases
    Potential future developments in the field of static code analysis
    Practical applications of using linters like Credo and RuboCop in software development
    Links mentioned in this episode:
    Credo https://github.com/rrrene/credo
    https://hexdocs.pm/credo/overview.html
    Dogma: A code style linter for Elixir https://github.com/lpil/dogma
    https://github.com/rubocop/rubocop
    RuboCop's AST extensions and NodePattern functionality https://github.com/rubocop/rubocop-ast
    https://github.com/whitequark/parser
    https://hex.pm/packages?search=credo&sort=recentdownloads
    https://github.com/doorgan/sourceror
    https://github.com/rrrene/credo/blob/master/lib/credo/check/readability/largenumbers.ex Special Guests: Marc-André Lafortune and René Föhring.

  • On today’s episode, Elixir Wizards Owen Bickford and Dan Ivovich compare notes on building web applications with Elixir and the Phoenix Framework versus Ruby on Rails. They discuss the history of both frameworks, key differences in architecture and approach, and deciding which programming language to use when starting a project.
    Both Phoenix and Rails are robust frameworks that enable developers to build high-quality web apps—Phoenix leverages functional programming in Elixir and Erlang’s networking for real-time communication. Rails follows object-oriented principles and has a vast ecosystem of plug-ins. For data-heavy CRUD apps, Phoenix's immutable data pipelines provide some advantages.
    Developers can build great web apps with either Phoenix or Rails. Phoenix may have a slight edge for new projects based on its functional approach, built-in real-time features like LiveView, and ability to scale efficiently. But, choosing the right tech stack depends heavily on the app's specific requirements and the team's existing skills.
    Topics discussed in this episode:
    History and evolution of Phoenix Framework and Ruby on Rails
    Default project structure and code organization preferences in each framework
    Comparing object-oriented vs functional programming paradigms
    CRUD app development and interaction with databases
    Live reloading capabilities in Phoenix LiveView vs Rails Turbolinks
    Leveraging WebSockets for real-time UI updates
    Testing frameworks like RSpec, Cucumber, Wallaby, and Capybara
    Dependency management and size of standard libraries
    Scalability and distribution across nodes
    Readability and approachability of object-oriented code
    Immutability and data pipelines in functional programming
    Types, specs, and static analysis with Dialyzer
    Monkey patching in Ruby vs extensible core language in Elixir
    Factors to consider when choosing between frameworks
    Experience training new developers on Phoenix and Rails
    Community influences on coding styles
    Real-world project examples and refactoring approaches
    Deployment and dev ops differences
    Popularity and adoption curves of both frameworks
    Ongoing research into improving Phoenix and Rails
    Links Mentioned in this Episode:
    SmartLogic.io (https://smartlogic.io/)
    Dan’s LinkedIn (https://www.linkedin.com/in/divovich/)
    Owen’s LinkedIn (https://www.linkedin.com/in/owen-bickford-8b6b1523a/)
    Ruby https://www.ruby-lang.org/en/
    Rails https://rubyonrails.org/
    Sams Teach Yourself Ruby in 21 Days (https://www.overdrive.com/media/56304/sams-teach-yourself-ruby-in-21-days)
    Learn Ruby in 7 Days (https://www.thriftbooks.com/w/learn-ruby-in-7-days---color-print---ruby-tutorial-for-guaranteed-quick-learning-ruby-guide-with-many-practical-examples-this-ruby-programming-book--to-build-real-life-software-projects/18539364/#edition=19727339&idiq=25678249)
    Build Your Own Ruby on Rails Web Applications (https://www.thriftbooks.com/w/build-your-own-ruby-on-rails-web-applications_patrick-lenz/725256/item/2315989/?utm_source=google&utm_medium=cpc&utm_campaign=low_vol_backlist_standard_shopping_customer_acquisition&utm_adgroup=&utm_term=&utm_content=593118743925&gad_source=1&gclid=CjwKCAiA1MCrBhAoEiwAC2d64aQyFawuU3znN0VFgGyjR0I-0vrXlseIvht0QPOqx4DjKjdpgjCMZhoC6PcQAvD_BwE#idiq=2315989&edition=3380836)
    Django https://github.com/django
    Sidekiq https://github.com/sidekiq
    Kafka https://kafka.apache.org/
    Phoenix Framework https://www.phoenixframework.org/
    Phoenix LiveView https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html#content
    Flask https://flask.palletsprojects.com/en/3.0.x/
    WebSockets API https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API
    WebSocket connection for Phoenix https://github.com/phoenixframework/websock
    Morph Dom https://github.com/patrick-steele-idem/morphdom
    Turbolinks https://github.com/turbolinks
    Ecto https://github.com/elixir-ecto
    Capybara Testing Framework https://teamcapybara.github.io/capybara/
    Wallaby Testing Framework https://wallabyjs.com/
    Cucumber Testing Framework https://cucumber.io/
    RSpec https://rspec.info/

  • Today on Elixir Wizards, Manuel Rubio, author of Erlang/OTP: A Concurrent World and Dan Plyukhin, creator of the UIGC Actor Garbage Collector for Akka, join host Dan Ivovich to compare notes on garbage collection in actor models.
    The discussion digs into the similarities and differences of actor-based garbage collection in Erlang and Akka and introduces Dan's research on how to perform garbage collection in a distributed actor system.
    Topics discussed:
    Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering
    Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements
    Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors
    Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes
    Challenges include reasoning about failures like dropped messages and crashed nodes
    GC balance requires optimization of resource release and CPU load management
    Immutability helps Erlang GC, but copying data for messages impacts performance
    Research into distributed actor GC is still ongoing, with opportunities for improvement
    Fault tolerance in Erlang relies on user implementation rather than low-level guarantees
    Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research
    Idempotent messaging is recommended to handle possible duplicates from failures
    Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases
    Links mentioned:
    Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i 
    Scala https://www.scala-lang.org/ 
    Akka Framework https://github.com/akka 
    JVM (Java Virtual Machine) https://www.java.com/en/download/ 
    The BEAM VM https://www.erlang.org/blog/a-brief-beam-primer/
    Hadoop Framework https://hadoop.apache.org/  
    Pony Programming Language https://www.ponylang.io/ 
    SLSA Programming Language https://wcl.cs.rpi.edu/salsa/#:~:text=SALSA%20
    Paxos Algorithm https://en.wikipedia.org/wiki/Paxos(computerscience) 
    Raft library for maintaining a replicated state machine https://github.com/etcd-io/raft 
    Dan's Website https://dplyukhin.github.io/ 
    Dan Plyukhin on Twitter: https://twitter.com/dplyukhin 
    Dan Plyukhin’s YouTube channel: https://m.youtube.com/@dplyukhin
    UIGC on GitHub https://github.com/dplyukhin/UIGC 
    Manuel's Website https://altenwald.com/ 
    Manuel Rubio on Twitter: https://twitter.com/MRonErlang Special Guests: Dan Plyukhin and Manuel Rubio.

  • In this episode of Elixir Wizards, Katelynn Burns, software engineer at LaunchScout, and Alexis Carpenter, senior data scientist at cars.com, join Host Dan Ivovich to discuss machine learning with Elixir, Python, SQL, and MATLAB. They compare notes on available tools, preprocessing, working with pre-trained models, and training models for specific jobs.
    The discussion inspires collaboration and learning across communities while revealing the foundational aspects of ML, such as understanding data and asking the right questions to solve problems effectively.
    Topics discussed:
    Using pre-trained models in Bumblebee for Elixir projects
    Training models using Python and SQL
    The importance of data preprocessing before building models
    Popular tools used for machine learning in different languages
    Getting started with ML by picking a personal project topic of interest
    Resources for ML aspirants, such as online courses, tutorials, and books
    The potential for Elixir to train more customized models in the future
    Similarities between ML approaches in different languages
    Collaboration opportunities across programming communities
    Choosing the right ML approach for the problem you're trying to solve
    Productionalizing models like fine-tuned LLM's
    The need for hands-on practice for learning ML skills
    Continued maturation of tools like Bumblebee in Elixir
    Katelynn's upcoming CodeBeam talk on advanced motion tracking
    Links mentioned in this episode
    https://launchscout.com/
    https://www.cars.com/
    Genetic Algorithms in Elixir (https://pragprog.com/titles/smgaelixir/genetic-algorithms-in-elixir/) by Sean Moriarity
    Machine Learning in Elixir (https://pragprog.com/titles/smelixir/machine-learning-in-elixir/) by Sean Moriarity
    https://github.com/elixir-nx/bumblebee
    https://github.com/huggingface
    https://www.docker.com/products/docker-hub/
    Programming with MATLAB (https://www.mathworks.com/products/matlab/programming-with-matlab.html)
    https://elixirforum.com/
    https://pypi.org/project/pyspark/ 
    Machine Learning Course (https://online.stanford.edu/courses/cs229-machine-learning) from Stanford School of Engineering
    Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) by Aurélien Géron
    Data Science for Business (https://data-science-for-biz.com/) by Foster Provost & Tom Fawcett
    https://medium.com/@carscomtech 
    https://github.com/k-burns 
    Code Beam America (https://codebeamamerica.com/) March, 2024
    Special Guests: Alexis Carpenter and Katelynn Burns.

  • This week on Elixir Wizards, Connor Rigby, Software Engineer at SmartRent, and Taylor Barto, Lead Embedded Software Engineer at Eaton, join Sundi Myint to compare notes on embedded systems development with Elixir, C, C++, and Java. They discuss using Elixir and the Nerves framework for firmware projects versus more traditional choices like C. The guests ask one another questions and gain valuable insights into challenges, tooling, resources, and more across different embedded ecosystems.
    In this episode, the guests expand their perspectives and demystify the concept of embedded systems for engineers outside the field. This cross-language exchange of ideas and experiences inspires continued learning and collaboration between embedded software engineers using different programming languages.
    Topics Discussed:
    Defining "true embedded": using an operating system vs. bare metal programming
    Benefits and drawbacks of Elixir, C, C++, and Java for firmware
    Many embedded systems today use Java as the programming language via Java Native Interface (JNI) to interface with C/C++ code
    How Elixir expands the toolbox available for firmware projects
    Testing, tooling, workflows, and debugging across languages
    Elixir/Nerves features like hot code reloading and testing vs. Java alternatives
    Learning curves for new languages and frameworks
    Industry trends around established vs emerging tools
    Applying functional programming principles like immutability in new domains
    Scaling firmware updates across large connected networks
    Continued maturation of Nerves may bring Elixir into consideration for roles where Java is commonly used today
    Hardening systems for reliability in safety-critical uses
    Debugging differences between web development and embedded
    Hiring considerations for niche languages
    Additional skills needed for embedded engineers, such as technical writing, reading schematics, and writing test instructions
    Resources and recommendations for getting started with embedded systems
    Links Mentioned:
    Nerves: https://github.com/nerves-project/nerves
    https://nerves-project.org/
    AtomVM: https://github.com/atomvm/AtomVM
    GRiSP: https://github.com/grisp
    RISC-V: https://github.com/ultraembedded/riscv
    https://smartrent.com/
    https://www.eaton.com/us/en-us.html
    Zig Programming Language: https://github.com/ziglang
    Docker: https://github.com/docker
    Build a Weather Station with Elixir and Nerves (https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/) by Alexander Koutmos, Bruce A. Tate, Frank Hunleth
    Build a Binary Clock with Elixir and Nerves (https://pragprog.com/titles/thnerves/build-a-binary-clock-with-elixir-and-nerves/) by Frank Hunleth and Bruce A. Tate
    http://esp32.net/
    https://www.nordicsemi.com/ Special Guests: Connor Rigby and Taylor Barto.

  • In Episode 4, the Elixir Wizards are joined by Dorian Iacobescu, author of the ECSpanse ECS library for Elixir, and Daniel Luu, founder and CEO of the game development studio AKREW. The guests compare notes on backend game development using ECS, the Entity Component System approach.
    Akrew is currently building the multiplayer game Galactic Getaway using the Photon Unity networking framework, which employs ECS. They discuss challenges like collections of component types and persistence beyond runtime, building games for various platforms like MacOS, and handling inventory storage in a backend database.
    Game development is complex and has many technical hurdles, but open communication across different programming communities and game development approaches can foster collaboration, innovation, and continued learning.
    Topics Discussed in this Episode
    Dorian explains the ECSpanse ECS library and component-based architecture
    Dorian took inspiration for ECSpanse from the Rust library Bevy ECS and its component-based API
    The guests discuss popular game development platforms and languages, including C#, JavaScript, and Godot
    Owen and Daniel translate ECS concepts to familiar database and backend terminology for devs without game-specific experience
    ECSpanse uses many tools from the Elixir Erlang toolbox, including GenServers, ETS tables, tasks, queries, and Phoenix LiveView
    ECS challenges representing inventory collections that broke typical ECS singleton patterns
    AKREW is developing Galactic Getaway using the Photon Unity framework
    Relationships between parent and child entities in ECSpanse
    Persistence, serialization, and replay features to save game state
    Optimizing assets and code for performance on various devices
    Links Mentioned
    https://en.wikipedia.org/wiki/Entitycomponentsystem
    https://iacobson.medium.com/elixir-for-fun-ecspanse-2852a7993ecd
    https://hexdocs.pm/ecspanse/Ecspanse.html
    https://bevyengine.org/learn/book/getting-started/ecs/
    https://www.photonengine.com/quantum
    Add Galactic Getaway to your Steam Wishlist: https://store.steampowered.com/app/2012390/GalacticGetaway/
    https://godotengine.org/
    https://unity.com/
    https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscriptbasics.html
    https://www.tiktok.com/@galacticgetaway
    https://docs.rs/bevyecs/latest/bevyecs/ Special Guests: Daniel Luu and Dorian Iacobescu.

  • This week, the Elixir Wizards are joined by Yohana Tesfazgi and Wes Bos to compare notes on the experience of learning Elixir vs. JavaScript as your first programming language. Yohana recently completed an Elixir apprenticeship, and Wes Bos is a renowned JavaScript educator with popular courses for beginner software developers.
    They discuss a variety of media and resources and how people with different learning styles benefit from video courses, articles, or more hands-on projects. They also discuss the current atmosphere for those looking to transition into an engineering career and how to stick out among the crowd when new to the scene.
    Topics Discussed in this Episode
    Pros and cons of learning Elixir as your first programming language
    Materials and resources for beginners to JavaScript and Elixir
    Projects and methods for learning Elixir with no prior knowledge
    Recommendations for sharpening and showcasing skills
    How to become a standout candidate for potential employers
    Soft skills like communication translate well from other careers to programming work
    Learning subsequent languages becomes more intuitive once you learn your first
    How to decide which library to use for a project
    How to build an online presence and why it’s important
    Open-source contributions are a way to learn from the community
    Ship early and often, just deploying a default Phoenix app teaches deployment skills
    Attend local meetups and conferences for mentoring and potential job opportunities
    Links Mentioned
    https://syntax.fm/
    https://fly.io/
    https://elixirschool.com/en
    Syntax.fm: Supper Club × How To Get Your First Dev Job With Stuart Bloxham (https://syntax.fm/show/667/supper-club-how-to-get-your-first-dev-job-with-stuart-bloxham)
    Quinnwilton.com (https://quinnwilton.com/)
    https://github.com/pallets/flask
    https://wesbos.com/courses
    https://beginnerjavascript.com/
    Free course: https://javascript30.com/
    https://pragmaticstudio.com/
    https://elixircasts.io/
    https://grox.io/
    LiveView Mastery YouTube Channel (https://www.youtube.com/channel/UC7T19hPLqQ-Od3Rb3T2OX1g)
    Contact Yohana: [email protected]

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

  • 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

  • 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 (https://youtu.be/gJJH7a2J9O8)
    Keynote: Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022 (https://youtu.be/Jf5Hsa1KOc8)
    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" (https://www.irif.fr/_media/users/gduboc/elixir-types.pdf) by G. Castagna, G. Duboc, and J. Valim
    "A Gradual Type System for Elixir" (https://dlnext.acm.org/doi/abs/10.1145/3427081.3427084) by M. Cassola, A. Talagorria, A. Pardo, and M. Viera
    "Programming with union, intersection, and negation types" (https://www.irif.fr/~gc/papers/set-theoretic-types-2022.pdf), by Giuseppe Castagna
    "Covariance and Contravariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)" (https://www.irif.fr/~gc/papers/covcon-again.pdf) by Giuseppe Castagna
    "A reckless introduction to Hindley-Milner type inference" (https://www.lesswrong.com/posts/vTS8K4NBSi9iyCrPo/a-reckless-introduction-to-hindley-milner-type-inference) Special Guests: Giuseppe Castagna, Guillaume Duboc, and José Valim.

  • 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 (https://youtu.be/FADQAnq0RpA)
    Keynote: I Was Wrong About LiveView by Jason Stiebs | ElixirConf 2022 (https://youtu.be/INgpJ3eIKZY)
    Phoenix Site https://www.phoenixframework.org/
    Phoenix Github https://github.com/phoenixframework
    Two-Story, 10-Room Purple Martin House (https://suncatcherstudio.com/uploads/birds/birdhouses/purple-martin-house-plans/images-large/purple-martin-birdhouse-plans-labeled.png)
    Blog: The Road to 2 Million Websocket Connections in Phoenix (https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections)
    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 (https://twitter.com/sundikhin/status/1663930854928728064)
    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.

  • 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/seanmoriarity
    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/salkhanhowaicouldsavenotdestroyeducation/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.

  • 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/elixirradar
    Livebook on Twitter: https://twitter.com/livebookdev
    Lucas’ Twitter https://twitter.com/dorgan
    Guillaume Duboc Bringing Types to Elixir at ElixirConf EU 2023 (https://www.youtube.com/watch?v=gJJH7a2J9O8)
    Lucas on GitHub: https://github.com/doorgan
    Rooster Fighter on Easter Island (https://preview.redd.it/7v4aqvvtcwk61.jpg?width=960&crop=smart&auto=webp&v=enabled&s=a6ec117965d192f4f32a68ace90388424d15ba29)
    Rooster Fighter at Iguazu Falls in Argentina (https://i.kym-cdn.com/photos/images/newsfeed/002/038/658/2c4)
    Use code WIZARD for $100 off your ticket to Empex NYC (https://ti.to/empex-ny/empex-nyc-2023) in Brooklyn, NY on June 9, 2023
    Special Guests: Hugo Baraúna and Lucas San Roman.

  • 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 (https://www.youtube.com/watch?v=xItzdrzY1Dc)
    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.

  • 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 (https://www.theerlangelist.com/)
    Towards Maintainable Elixir - Saša Jurić's Medium Blog Article Series (https://medium.com/very-big-things/towards-maintainable-elixir-the-core-and-the-interface-c267f0da43)
    Boundary (https://hex.pm/packages/boundary): Managing cross-module dependencies in Elixir projects
    Site Encrypt (https://hex.pm/packages/site_encrypt): Integrated Certification via Let's Encrypt for Elixir-powered sites
    Authentication Generator in Phoenix: https://hexdocs.pm/phoenix/mixphxgen_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ć.

  • 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 (https://www.youtube.com/watch?v=FtZBTUvRt0g)
    Thousand Island - https://hexdocs.pm/thousand_island/ThousandIsland.html
    Special Guest: Mat Trudel.