Elixir Wizards is an interview-style podcast for anyone interested in functional programming and the Elixir Programming Language. Hosted by SmartLogic engineers and Elixirists Owen Bickford, Dan Ivovich, and Sundi Myint, this show features in-depth discussions with some of the brightest minds in the industry, discussing training and documentation in Phoenix LiveView, the evolution of programming languages, Erlang VM, and more.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin
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.
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
Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i
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_(computer_science)
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.
Machine Learning in Elixir vs. Python, SQL, and Matlab with Katelynn Burns & Alexis Carpenter
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.
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
Genetic Algorithms in Elixir by Sean Moriarity
Machine Learning in Elixir by Sean Moriarity
Programming with MATLAB
Machine Learning Course from Stanford School of Engineering
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow by Aurélien Géron
Data Science for Business by Foster Provost & Tom Fawcett
Code Beam America March, 2024
Special Guests: Alexis Carpenter and Katelynn Burns.
Embedded Systems in Elixir vs. C, C++, and Java with Connor Rigby & Taylor Barto
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.
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
Zig Programming Language: https://github.com/ziglang
Build a Weather Station with Elixir and Nerves by Alexander Koutmos, Bruce A. Tate, Frank Hunleth
Build a Binary Clock with Elixir and Nerves by Frank Hunleth and Bruce A. Tate
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
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
Add Galactic Getaway to your Steam Wishlist: https://store.steampowered.com/app/2012390/Galactic_Getaway/
Special Guests: Daniel Luu and Dorian Iacobescu.
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
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
Syntax.fm: Supper Club × How To Get Your First Dev Job With Stuart Bloxham
LiveView Mastery YouTube Channel
Contact Yohana: firstname.lastname@example.org
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
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
Guardian Library: https://github.com/ueberauth/guardian
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
Tesla Testing: https://hexdocs.pm/tesla/readme.html#testing
Tesla Mock: https://hexdocs.pm/tesla/Tesla.Mock.html
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.
I’ve been listening to Elixir Wizards for awhile now. It’s my one stop for great elixir content. They are always bringing something fresh to the table and I love how they interview members of the community!
A fun podcast about Elixir and their ecosystem
I’ve been a guest a few times, and love working with the Wizards. They have a great, laid back interview process, and I always look forward to listening to their episodes.
A Unique Look at Elixir
A different and worthwhile look at Elixir that brings a unique show to the community. Worth every minute I spend listening.