Sign up to save your podcasts
Or
Share Elixir Wizards
Share to email
Share to Facebook
Share to X
Share to email
Share to Facebook
Share to X
Or
Elixir Wizards
Elixir Wizards episodes
- Season 3 Trailer
Welcome back to Season 3! Our theme this time around is Working with Elixir. Listen for more on our theme, upcoming guests, and our new name.
2 min - Season Two Wrap
Welcome to the last episode of Season 2 of the podcast! We are taking this opportunity to recap what we covered in the season and talk about what we liked and what we didn't like so much. We do not have a guest for today's show so it is just Eric and Justus doing some reflection. We do want to take this opportunity to thank all of our guests that have appeared on this season and shared their expertise with us, we definitely feel we learned a lot during this time! In Season 3 we will be focussing on functional programming, performance and teaching Elixir, so make sure to keep an eye out for when that drops in the future!
Key Points From This Episode:
- The possibility of longer episodes for next season
- Reflections on ElixirConf and the time we spent there this year.
- The upcoming conference in New Orleans that Eric is keynoting.
- Thoughts on the future of the podcast and the promise of Season 3.
- Reach out! We want to hear from you!
- And much more!
Links Mentioned in Today’s Episode:
SmartLogic — https://www.smartlogic.io
Brooklyn Zelenka — https://github.com/expedeBryan Joseph — https://github.com/bryanjosPaul Schoenfelder — https://github.com/bitwalkerMeryl Dakin— https://github.com/meryldakinRené Föhring— https://twitter.com/rrreneMichal Muskala — https://michal.muskala.eu/Todd Resudek — https://www.linkedin.com/in/toddresudek/Shanti Chellaram— https://github.com/shantiiiSophie DeBenedetto — http://sophiedebenedetto.nyc/Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441bElixirConf — https://elixirconf.com/2019The Big Elixir — https://www.thebigelixir.com/Le Petit Theatre — http://www.lepetittheatre.comLone Star Elixir — https://www.lonestarelixir.comThe Empire Strikes Back — https://www.rottentomatoes.com/m/empire_strikes_back12 min - Dave Lucia on Rustler – Elixir Internals
Our guest today on the show is Dave Lucia, who is currently the Vice President of Engineering at SimpleBet. He is here as part of Elixir Internals series, to talk to us and all our listeners about Rustler and the contribution he made to the library! According to our guest, Rustler acts as a bridge between Rust and Elixir and allows users to employ the power of Rust within Elixir and a great example of this can be found in Dave's work at SimpleBet. He explains some of this application and the functionality and improvement it offers and the big difference the machine learning models make to this work. Dave also gives us some background to his work and career, previous employment and early explorations of open-source software. He also shares some great tips for problem-solving and learning and improving at programming in Rust. We unpack some of the biggest challenges that faced the creation of Rustler, notable differences between Rust and Elixir and the technical components of the library that the team created. For all this and then some, join us for this great episode!
Key Points From This Episode:
- More about our guest and his current work at SimpleBet.
- How Dave got started with Elixir while at Bloomberg.
- The interesting and beautiful way in which The Outline used Elixir.
- Dave's early forays and experiences with open source software.
- Problem finding and solving; Dave's tips to those wanting to improve.
- Dave's employers' contribution and allowance for open source projects.
- Introducing Rustler and what users can do with it!
- The biggest challenges of using multiple languages in the backend.
- How Rustler works; the core, the code generator and more.
- The most important differences between Rust and Elixir.
- Dave's best advice and resources for learning and mastering Rust.
- And much more!
Links Mentioned in Today’s Episode:
SmartLogic — https://www.smartlogic.io
Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441bRustler — https://github.com/rusterlium/rustlerSimpleBet — https://simplebet.ioDave Lucia on Twitter — https://twitter.com/davydog187Dave Lucia Email — [email protected]Elixir — https://elixir-lang.orgPython — https://www.python.orgJavaScript — https://www.javascript.comRust — https://www.rust-lang.orgBloomberg — https://www.bloomberg.comSlack — https://slack.comVox Media — https://www.voxmedia.comThe Outline — https://theoutline.comThe Rust Programming Language — https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284Rust Playground — https://play.rust-lang.orgElm Compiler — https://github.com/elm/compilerSpecial Guest: Dave Lucia.
33 min - Eric Oestrich on ExVenture – Elixir Internals
This season on Smart Software Season 2, we are focused on the inner workings of Elixir and the inner workings of popular Elixir libraries, or Elixir internals. Today, I have the pleasure of interviewing my colleague, Eric Oestrich who's responsible for the wildly successful Elixir MUD framework ExVenture.
ExVenture - https://exventure.org/
MUDs - https://en.wikipedia.org/wiki/MUDEcto - https://github.com/elixir-ecto/ectoEric's Going Multi-Node presentation at ElixirConf - https://www.youtube.com/watch?v=lCUKQnkjajoThe Big Elixir - https://www.thebigelixir.com/Eric's Prometheus presentation at Lonestar Elixir - https://www.youtube.com/watch?v=ETUD9SaRCjYPrometheus - https://prometheus.io/Go - https://golang.org/Celluloid - https://celluloid.io/Phoenix - https://phoenixframework.org/Grapevine - https://grapevine.haus/Gossip - https://mudcoders.com/gossip-the-mud-chat-network-3156cf24edf/Learn more about how SmartLogic uses Phoenix and Elixir.
30 min - Sophie DeBenedetto on Excrypt and Railway – Elixir Internals
Welcome to another episode of the podcast everybody! As we continue our journey into Elixir internals in Season 2, we welcome Sophie DeBenedetto to tell us about the two libraries she and the Flatiron School created! We talk about Encrypt and Railway and a bunch of other great stuff from the world of Elixir and open source and Sophie shares so much about why she is particularly excited about things at the moment. She talks about the maturation of the Elixir community and her first and most important open-source experiences before diving into her hopes for the future of these platforms. We also discuss the ins and out of the two libraries and our guest does a fantastic job of explaining their functions and the reasons they were built. Sophie shares the major challenges that faced her and the team in creating them and a whole lot more, so make sure to tune in today for all this great information!
Key Points From This Episode:
- A brief introduction to Sophie's career, the Flatiron School and her Elixir work.
- Sophie's first experiences with open source, contributing to the Elixir School.
- Flatiron's support of open source and their attitude towards the growth of engineers.
- Why Elixir and Ruby are such important languages to Sophie and Flatiron.
- Sophie's wishes for Elixir and what she wants to see more of in the community.
- Introducing Encrypt and Excrypt for Elixir and why Flatiron chose to build them.
- The hardest parts of building the library, the challenges of encryption.
- Elixir's built-in option parser; convenience and accessing data easily.
- The Railway hex package and what it enables users to do.
- Breaking down the functions of RabbitMQ for Erlang.
- The two things that Sophie is most excited about in the Elixir space right now!
- And much more!
Links Mentioned in Today’s Episode:
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Flatiron School — http://sophiedebenedetto.nyc/Elixir School — https://elixirschool.com/en/Encrypt — https://github.com/flatiron-labs/encryptEscript — https://hexdocs.pm/mix/master/Mix.Tasks.Escript.Build.htmlRuby — https://www.ruby-lang.org/en/Kafka — https://kafka.apache.orgEcto — https://hexdocs.pm/ecto/Ecto.htmlErlang — https://www.erlang.orgRabbitMQ — https://www.rabbitmq.comPhoenix — https://phoenixframework.orgLiveView — https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascriptElixir Conf — https://elixirconf.com/2019Special Guest: Sophie DeBenedetto.
31 min - Shanti Chellaram on Pri-Queue and raft_erl – Elixir Internals
Today on the show we welcome Shanti Chellaram to talk about a couple of Erlang libraries she has created! We hear from her about Pri-Queue and raft_erl, and her motivation behind making them and some of the things we wishes she did differently! Shanti shares some of her background, early coding experiences, affinity for open source and her current work situation. From there we look at Pri-Queue, the problem it addresses and what a priority queue is. A highlight of the show is Shanti giving the best explanation of a bootstrapped skew binomial heap we have heard before explaining some of the main issues she faced in creating Pri-Queue. We then turn to raft_erl, how she got started with it and her hopes for its future. Throughout the conversation Shanti shares her philosophy towards open source and coding going forward as well as offering advice for newcomers to Erlang. Make you you join us for this fantastic episode!
Key Points From This Episode:
- A little bit about Shanti's background and current employment.
- Shanti's early experiences and what got her into open source software.
- Some coding decisions that Shanti would make differently in retrospect.
- The problem that Pri-Queue solves; the dearth of data efficient libraries.
- What is a priority queue? Ordering your data with scores.
- Shanti explains a bootstrapped skew binomial heap!
- Some of the hurdles that Shanti faced in writing Pri-Queue.
- How Shanti got started on her other library, raft_erl.
- The three Raft protocols and how much of it is implemented in the library.
- Shanti's next goals for raft_erl; bug free and widely used.
- The importance of distributed systems and Shanti's philosophy looking to the future.
- Advice for someone just starting out in Elixir!
- And much more!
Links Mentioned in Today’s Episode:
SmartLogic — https://www.smartlogic.io/
Shanti Chellaram Linkedin— https://www.linkedin.com/in/shanti-chellaram-495444187Shanti Chellaram on Twitter — https://twitter.com/theccoderShanti Chellaram on github — https://github.com/shantiiiErlang — https://www.erlang.org/Elixir — https://elixir-lang.org/Pri-Queue — https://github.com/okeuday/pqueueraft_erl — https://github.com/shantiii/raft_erlMailChimp — https://mailchimp.comTeachers Pay Teachers — https://www.teacherspayteachers.com/Purely Functional Data Structures — https://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki-ebook/dp/B00AKE1V04Rust — https://www.rust-lang.org/Raft — https://raft.github.io/Raspberry Pi — https://www.raspberrypi.org/ElixirConf — https://elixirconf.com/2019Partisan — https://partisan.cloud/Special Guests: Dan Ivovich and Shanti Chellaram.
29 min - Michał Muskała on Ecto and jason – Elixir Internals
Today on the show we are joined by Michal Muskala, who is currently a freelance software engineer and he is here to talk to us about his work on the Ecto and jason libraries. With Ecto we continue our journey into Elixir and Michal explain how he became involved in the project and the work he did on it. He explains a little of its inner workings, issues and what excited him about it initially. We then turn to jason, a widely popular library that Michal created for parsing JSON. Michal unpacks its particulars, differentiating for us between the driver and adapter and the lessons he learned working on them. The last bit of our conversation is spent talking about open source and Michal's commitment to its philosophy. We discuss making time to work on projects, buy in from employers and and why getting involved can be scary yet is so important! For all this and more, join us for this great episode!
Key Points From This Episode:
- A little bit about Michal's work background and how he got started on Elixir.
- The parts of Ecto that Michal worked on at Google Summer of Code.
- Differentiating between the driver and the adapter; communicating with the database.
- Structuring the code and what Michal would do differently now.
- Creating jason, the default JSON parser and the impetus behind it.
- Understanding lexing and tokenizing; largely the same thing with different names.
- Macros on jason and forcing the VM to use optimizations in particular cases.
- Performance on jason; how Michal achieved the speeds he did.
- Michal's path to open source software and what followed his work in MongoDB.
- Finding time to work on open source projects while employed.
- BEAM, alternative implementations and why they are important.
- Michal's call to action for our listeners!
- And much more!
Links Mentioned in Today’s Episode:
SmartLogic — https://www.smartlogic.io/
Elixir — https://elixir-lang.org/Michal Muskala — https://michal.muskala.eu/Michal Muskala on Twitter — https://twitter.com/michalmuskala?lang=enEcto — https://hexdocs.pm/ecto/Ecto.htmljason — https://github.com/michalmuskala/jasonGoogle Summer of Code — https://summerofcode.withgoogle.com/MondoDB — https://www.mongodb.com/Erlang — https://www.erlang.org/Binary Optimization in Erlang Documentation — https://rhye.org/post/erlang-binary-matching-performance/ (Please verify link)BEAM — https://blog.stenmans.org/theBeamBook/Erjang — https://jaxenter.com/introducing-erjang-erlang-for-the-jvm-108005.htmlAtom VM — http://atomvm.sourceforge.net/Special Guest: Michał Muskała.
28 min - Todd Resudek on Hex – Elixir Internals
Today on the show we get stuck into the inner workings of Hex 1.0 and are happy to be joined by returning guest, Todd Resudek. As you might already know, Todd is the Senior Software Engineer at Weedmaps, a regular speaker on the conference scene, and one of the three core team members at Hex. With the total downloads sitting at 641 million, the Hex community is growing rapidly and shows no signs of slowing down. In this episode, we discover what makes the Hex packages some of the most popular packages out there today, as well as the new and improved features currently in the pipeline. In addition, we find out how Todd first got involved with the Hex team and how the team makes decisions and problem solves.
Key Points From This Episode:
- Transferring a new library into an old ecosystem.
- Todd’s challenges learning Elixir and Hex.
- Learn more about the functions of Alphabetify.
- An introduction to the uses of ETS storage.
- Contributing to Open Source while working at Weedmaps.
- Discover how Todd got involved with the Hex team.
- Learn more about the different faces of Hex.
- Find out how decisions are made within the Hex team.
- Just how busy is the Hex community right now?
- The top five underground features of Hex.
- Discover the latest features now available on Hex.
- Find out what new Hex features are in the pipeline.
- And much more!
Links Mentioned in Today’s Episode:
Todd Resudek — https://www.linkedin.com/in/toddresudek/
Weedmaps — https://weedmaps.com/Hex — https://hex.pm/rebar3 — https://www.rebar3.org/Alphabetify — https://hex.pm/packages/alphabetifyETS — https://elixirschool.com/en/lessons/specifics/ets/Elixir Mix Podcast — https://devchat.tv/elixir-mix/Voitek — https://voitekk.com/Erlef Erlang Ecosystem Foundation — https://erlef.org/Crates — https://crates.io/crates/hexSmart Software with SmartLogic — https://podcast.smartlogic.io/Nerves MeetUp on Twitter — https://twitter.com/nervesmeetupThe Big Elixir — https://www.thebigelixir.com/Special Guest: Todd Resudek.
34 min - Chris Keathley on Wallaby and Raft – Elixir Internals
In this episode of the podcast we are joined by Chris Keathley to continue our exploration of Elixir internals as he tells us about two very popular libraries that he developed, Wallaby and Raft. We start off with some background and his initial experiences with Elixir and open source projects before diving into Wallaby and some of the biggest lessons that Chris learned during and after his work on the library.
Chris does a great job of explaining concurrent tests and the Sandbox and some of the reasons he has pretty much stopped working on the front end of projects. From there we move onto another one of Chris' exciting projects, Raft! In order to introduce the library, Chris explains more about consensus algorithms, Leslie Lamport and his groundbreaking work on Paxos. Raft is, in some ways, a simplified, more accessible version of Paxos for Elixir and Chris goes on to give a brief rundown of its inner workings. For this great conversation with a great guest, join us today!
Key Points From This Episode:
- Chris' background, history with Elixir and his current employment.
- How Chris got started with open source work.
- Why Chris has moved away from front end work in the last while.
- The major lessons Chris learned while building Wallaby.
- How the concurrent tests work on Wallaby and the Sandbox.
- Why Chris is still excited about Raft, even though he hasn't touched it in a while.
- Explaining Raft, consensus algorithms and Paxos.
- How the Raft library actually works; building Raft systems and processes.
- Where to find and connect with Chris online!
- And much more!
Links Mentioned in Today’s Episode:
SmartLogic — https://www.smartlogic.io/
Chris Keathley — https://keathley.io/Chris Keathley on github — https://github.com/keathleyBleacher Report — https://bleacherreport.com/Wallaby — https://hexdocs.pm/wallaby/Wallaby.htmlRaft — https://raft.github.io/Erlang — https://www.erlang.org/Slack — https://slack.com/Leslie Lamport — http://www.lamport.org/Paxos Made Live — https://blog.acolyer.org/2015/03/05/paxos-made-live/Elixir Outlaws Podcast — https://elixiroutlaws.com/Special Guest: Chris Keathley.
27 min - René Föhring on Credo – Elixir Internals
Welcome back to the SmartLogic Podcast where we talk about the latest developments and best practices in the web and mobile software industry. In continuing with our theme of Elixir Internals, we’re having a conversation about the inner workings of one of the most popular Elixir libraries, Credo, and we are joined by the author René Föhring.
René shares the story of how he was introduced to Elixir while doing his PhD and looking for a new programming language and then shares the philosophy and inspiration Credo was developed on. Wanting Credo to be a less rule-based, authoritative code analysis tool and more user friendly, René focused on creating it to act as a type of digital mentor to the many developers out there who do not have a human mentor. He also shares about some of the launching hiccups, what he would have done differently had he been given another opportunity and some of the most important lessons that he has learned working in the open source community. Be sure to join us for all the inside info!
Key Points from This Episode:
- More about René’s job as head of product development at 5 Minds and what they do.
- What he does in his free time: open source maintenance and conference speaking.
- How he got started with Elixir and wanting to learn a new programming language.
- What Credo is all about, why you’d want to use it and what makes it different.
- The inspiration behind writing Credo and wanting a more positive, less dogmatic tool.
- Starting off building on Dogma but then pivoting and going in an independent direction.
- The hiccups René experienced when first releasing Credo and what he’d do differently.
- The different checks in Credo and how they function and respond to issues.
- How Elixir 1.6 impacted the development of Credo.
- What’s new with the Credo 1.1 release?
- René’s experience working with open source and the first library he contributed to.
- Important lessons he has learned by being part of the open source community.
- And much more!
Links Mentioned in Today’s Episode:
Elixir — https://elixir-lang.org/
Credo — http://credo-ci.org/René Föhring on Twitter — https://twitter.com/rrrene?lang=en5 Minds IT – Solutions — https://www.5minds.de/GitHub — https://github.com/Ruby — https://www.ruby-lang.org/en/Go — https://golang.org/Cplusplus — http://www.cplusplus.com/StyleCop — https://github.com/StyleCop/StyleCopDogma — https://github.com/lpil/dogmaHex — https://hex.pm/Learn more about how SmartLogic uses Phoenix and Elixir.
Special Guest: René Föhring.
30 min
About Elixir Wizards
From the publisher's feed
Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software…
development landscape. Each episode explores how modern systems are built, from distributed architectures and infrastructure to developer workflows, security, and emerging technologies like AI. While rooted in the Elixir ecosystem, the show often branches out to compare approaches across languages, platforms, and disciplines. Whether you’re working in Elixir or just interested in how software is evolving, Elixir Wizards offers practical insights and thoughtful perspectives from the people building today’s systems.