Elixir Wizards

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.

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: yytesfazgi@gmail.com

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.