
Elixir Wizards
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.
In the current season, we're branching out from Elixir to compare notes with thought leaders and software engineers from programming languages like JavaScript, Ruby on Rails, Go, Scala, Java, and more. Each episode will take a deep dive into a topic from Machine Learning and AI, to ECS and game development, to education and community.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
Latest episodes

Feb 27, 2020 • 1h 11min
Bonus Toddcast & Lonestar Preview
This week we're delighted to share a special format bonus episode!
We are joined by guest co-host Todd Resudek as well as a number of guests who each share a little bit about what they're working on and in many cases their upcoming presentations at Lonestar Elixir.
Special episode guests:
Angel Jose, Senior Platform Engineer at Cars.com
Dave Lucia, VP of Engineering at SimpleBet
Greg Mefford, Senior Back-End Engineer at Bleacher Report
Melvin Cedeno, Elixir Developer at SplitGyms
Zach Thomas, API Developer at Blinker
Most of our guests weigh in about their upcoming presentations at the event and we also get to chat about a few near and dear topics with our rotating cast. We hear about where they are working, their experiences with Elixir and their thoughts on education and company culture. It's an unusual episode but one we are so glad to have had the chance to make! We also find time to touch on our focus for the next season of the podcast, which is very exciting for all of us over here at the show. Remember to stay plugged in for more on Lonestar Elixir and attend if you can!
Key Points From This Episode:
Some thoughts on LiveView and its adoption by new developers.
Angel's work at Cars and how they are using Elixir and LiveView to rewrite everything.
Chatbots and the immediate benefits of using Elixir to rewrite them.
The elevator pitch on SimpleBet and the tech stack, skillset and ecosystem of the company.
Why Dave and his team have moved away from Rust!
A quick tease of what to expect for Season 4 of the podcast: Architecture of Applications!
How Bleacher Report is using Elixir to build the 'third space' for sports fans.
Team building and expansion at Bleacher Report and the stages of scaling.
A sneak preview of Greg's upcoming talk at Lonestar!
How Greg got started with Nerves and why it has a special place in his heart.
The theme of Melvin's talk at Lonestar; untraditional routes and emotions in tech.
Considering the usefulness of boot camps, the value of ISAs and CS programs.
Zach's background in Elixir and his current work at Blinker with the language.
Experiences at Turing and in liberal arts during college.
Zach's Lonestar talk elevator pitch: 'Getting the Frog out of the Well'.
The allegory of the cave, 'what is water' and how this differs from Zach's idea.
Why don't we like statically typed things as much as we should?
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Lonestar Elixir 2020 — https://lonestarelixir.com/
Todd Resudek — https://medium.com/@toddresudek
Todd Resudek on Twitter — https://twitter.com/sprsmpl
Angel Jose — https://github.com/ajose01
Dave Lucia — https://github.com/davydog187
Greg Mefford — https://github.com/GregMefford/blinkchain
Melvin Cedeno — https://gist.github.com/normanrs/eeb5cc91cb10eeb7d3e43168396efb27
Zack Thomas — https://github.com/zeam-vm/pelemay
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
ElixirConf — https://elixirconf.com/events
Cars — https://www.cars.com/
SimpleBet — https://www.simplebet.io/
Full Stack Developer Horse Drawing Meme — https://knowyourmeme.com/photos/1624070-unfinished-horse-drawing
Conway's Law — https://www.thoughtworks.com/insights/blog/applying-conways-law-improve-your-software-development
ElixirConf 2019 - Lighting Talk - Are There Benefits Of Crying In Tech — https://www.youtube.com/watch?v=oW5Plkroyxk
TRON — https://www.rottentomatoes.com/m/tron
Smart Mirror Blog Post — https://medium.com/@toddresudek/building-a-smart-mirror-with-phoenix-liveview-18193ee6438f
Bleacher Report — https://bleacherreport.com/
Team Topologies — https://teamtopologies.com/
Nerves — https://nerves-project.org/
Turing — https://turing.io/
CIRR — https://cirr.org/
David Heinemeier Hansson — https://dhh.dk/
Blinker — https://www.blinker.com/
David Foster Wallace — http://www.davidfosterwallacebooks.com/
Gödel, Escher, Bach — https://www.goodreads.com/book/show/24113.G_del_Escher_BachSpecial Guests: Angel Jose, Dave Lucia, Greg Mefford, Melvin Cedeno, Todd Resudek, and Zach Thomas.

Feb 20, 2020 • 26min
Alex Garibay and Mike Binns from DockYard on Hiring and Training
Today on the show, we’re joined by Mike Binns and Alex Garibay of DockYard. In this episode, Mike and Alex share their journeys of how they came to work at DockYard and give us a view into DockYard’s hiring and training processes, systems, and philosophies. Here they share what they enjoy most about working at DockYard and their emphasis on being supported in your continual growth as an employee and human being.
Key Points from This Episode:
Find out how Mike and Alex both got their jobs at DockYard in 2016.
Working for a fully remote company: Mike and Alex share their experiences.
The amount of languages used at DockYard and what the day-to-day looks like.
React VS Ember: Find out DockYard’s opinion on the debate between the two.
How to know whether you should be using JavaScript or Live View on your projects.
The importance of inclusion and empowerment in the onboarding process at DockYard.
How to support and train new employees in “soft” skills, such as communication.
Personal strategies Mike and Alex use to help “soften the blow” of feedback and criticism.
Discover what DockYard does to support the learning growth of their employees.
Learn more about DockYard Friday and the exciting projects that have emerged from it.
Helpful resources for learning Elixir and how to remain a curious learner as a developer.
Find out the top skills that make a great engineering manager at DockYard today.
Links Mentioned in Today’s Episode:
Mike Binns on Twitter — https://twitter.com/1stAvenger
Mike Binns on LinkedIn — https://www.linkedin.com/in/mikebinns
Alex Garibay — https://alexgaribay.com/
Alex Garibay on Twitter — https://twitter.com/_AlexGaribay
Alex Garibay on LinkedIn — https://www.linkedin.com/in/alexandergaribay/
DockYard — https://DockYard.com/
SmartLogic — https://smartlogic.io/
RailsConf — https://railsconf.com/
Chris McCord — http://chrismccord.com/
Ember — https://emberjs.com/
Live View — https://support.google.com/maps/thread/11554255?hl=en
Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/1617295027
Elixir Conf 2014 Keynote by Dave Thomas — https://www.youtube.com/watch?v=5hDVftaPQwY
Sarah Drasner — https://sarahdrasnerdesign.com/
Lonestar Elixir — https://lonestarelixir.com/
Programming Phoenix — https://www.amazon.com/Programming-Phoenix-Productive-Reliable-Fast/dp/1680501453
Jason Goldberger — https://twitter.com/jsonlouis_Special Guests: Alex Garibay and Mike Binns.

Feb 13, 2020 • 35min
Sean Lewis from Divvy on Performance, Hiring and Training
Today on Elixir Wizards we are delighted to be joined by Sean Lewis, a senior backend architect at Divvy. One of the many impressive facts about Sean is that he is entirely self-taught, from dabbling in Python and coding to eventually writing a bunch of Ruby tests and working his way up in the product development sphere. In his free time, he likes to play around with electronics and work on other tech-related projects such as developing custom smart home devices. In this episode, Sean discusses his recent Meetup talk on the implementation of Broadway and explains Divvy’s tech stack choices that include React, Elixir, and Python. He dives into the topic of hiring for Elixir, outlining the challenges and providing strategies and resources to equip new developers in the area of functional programming. For Sean, the most important aspect of onboarding is teaching newcomers to ask the right questions since this is the foundation of the problem-solving process. He shares about Divvy’s approach to recruitment, his role as mentor, how they go about retaining and continuously growing their developers, the importance of being teachable, and then Sean concludes by giving listeners practical advice for ensuring data fidelity.
Key Points From This Episode:
Sean’s self-taught journey and role as senior backend architect at Divvy.
The smart home projects he has recently worked on, including a smart garage.
An overview of Broadway and Sean’s Meetup talk regarding implementation.
The straightforward tech stack at Divvy: React, Elixir, and Python.
The difficulty of hiring for Elixir and finding fintech companies that use Elixir.
Strategies and resources for training new engineers on Elixir and functional programming.
Why fintech works well with functional programming in the context of authorization.
Training state-minimization as a primary concern.
Onboarding: a process of teaching developers to ask the right questions.
Divvy’s approach to finding and recruiting new employees.
Thoughts on why so many Utahn companies use Elixir and the city’s exponential growth.
How Sean was recruited by Divvy, his progression to architect, and his role as a mentor.
Critical practices for onboarding developers, including assimilating them into the culture.
How Devvy continues to grow and retain its engineers.
The importance of challenging yourself, constantly learning, and staying teachable.
Implementing high-quality checkpoints and other advice for ensuring data fidelity.
Links Mentioned in Today’s Episode:
Sean Lewis on LinkedIn — https://www.linkedin.com/in/sean-lewis-40375077/
Sean Lewis on Twitter — https://twitter.com/fricsean?lang=en
Sean Lewis on GitHub — https://github.com/SophisticaSean
Divvy — https://getdivvy.com
Ruby — https://www.ruby-lang.org/en/
Broadway — https://hexdocs.pm/broadway/amazon-sqs.html
Utah Elixir Meetup — https://www.meetup.com/utah-elixir
React — https://reactjs.org
Elixir — https://elixir-lang.org
Susumu Yamazaki on Twitter — https://twitter.com/zacky1972
Domain Modeling Made Functional — https://www.amazon.com/Domain-Modeling-Made-Functional-Domain-Driven-ebook/dp/B07B44BPFB
Slack — https://slack.com/
MongoDB — https://www.mongodb.com
PostgreSQL — https://www.postgresql.org
Elixir Wizards Podcast — https://podcast.smartlogic.io
SmartLogic — https://smartlogic.io/ Special Guest: Sean Lewis.

Feb 6, 2020 • 52min
Paul Schoenfelder and Hans Elias Josephsen on Lumen and Performance
In line with our current working-with-Elixir theme, today we’re talking about performance with Paul Schoenfelder and Hans Elias Josephsen from DockYard. The two have been working on Lumen, and in this episode, they discuss how this project is incorporated with WebAssembly, a binary instruction format that ultimately allows Elixir to be run in the browser and preserve the semantics of the language. Paul and Hans talk about the specific aspects of Lumen they are working on; the data flow and process of writing Elixir; and the compiler, interpreter and run-time functions involved. Joining in this conversation, you will also hear how they approached starting developing Lumen as a brand new compiler, researching, the aspects Paul wanted to tackle first, and when users can expect Lumen to be released. We also talk about the performance concerns they encountered along the way, the many reasons why Rust was their programming language of choice, and their thoughts on generic associated types in Rust.
Key Points From This Episode:
• How Paul and Hans got introduced to Elixir and working for DockYard.
• An overview of what Lumen is and how it relates to WebAssembly.
• WebAssembly code to run Elixir in the browser and preserve the semantics of the language.
• The different aspects of the Lumen project that Paul and Hans are involved in.
• The data flow and process when writing Elixir and how the compiler function features.
• Taking advantage of optimizations that can be performed on the code that is generated.
• An explanation of the interpreter and run-time parts of the project.
• How they approached the major task of starting with a brand new compiler.
• The process of researching and why Paul wanted to get a frontend in place first.
• The production readiness of Lumen and when they expect to release it.
• Performance concerns they encountered during development.
• The relevance of code size for the WebAssembly backend to be usable.
• Why Rust was the best choice for building the compiler.
• Using Elixir to generate a standard binary that can run on any machine.
• A description of generic associated types in Rust and why they are controversial.
Links Mentioned in Today’s Episode:
Paul Schoenfelder on LinkedIn — https://www.linkedin.com/in/gotbones/
Paul Schoenfelder on Twitter — https://twitter.com/gotbones?lang=en
Hans Elias Josephsen on Twitter — https://twitter.com/hansihe
DockYard — https://dockyard.com
Elixir — https://elixir-lang.org
WebAssembly — https://webassembly.org
Rust — https://www.rust-lang.org
JavaScript — https://www.javascript.com
C++ — http://www.cplusplus.com
SmartLogic — https://smartlogic.io/ Special Guests: Hans Elias Josephsen and Paul Schoenfelder.

Jan 30, 2020 • 45min
Sophie DeBenedetto and Meryl Dakin on Training and Building Elixir Projects Under Constraints
Today on the show we are joined by Sophie DeBenedetto from GitHub and Meryl Dakin from Frame.io to talk about the processes involved in training others and building Elixir projects. They share about studying and working together at the Flatiron School and what they do now in their respective new roles at Github and Frame.io. During their time at Flatiron, they worked on various projects, often collaborating with engineering teams from other companies and having to train these team members in Elixir. They talk about how they managed to develop new features while simultaneously onboarding new people and getting everyone on the same page. For them, the pair programming model had been most beneficial, and they discuss the habits and practices they implemented to encourage team members, optimize each learning experience, and share knowledge during training events. Sophie and Meryl also share the Elixir-specific challenges they encountered while developing applications for 2U, how Elixir’s failure-first programming capability guided them, how they prepare for training workshops, and the productivity hacks that keep them focused and energized.
Key Points From This Episode:
• How Sophie and Meryl know each other from working and studying at the Flatiron School.
• Frame.io as a tool that facilitates the communication between video editors and clients.
• Meryl’s new role as a full-stack developer working with Elixir and React.
• The projects they worked on at Flatiron and partnering with various companies like 2U.
• Their secret to developing new features while also introducing new team members to Elixir.
• The benefits of pair programming and teaching a programming language to others.
• Reserving time to celebrate wins and knowledge share during training events.
• Key lessons they learned from their collaboration with the 2U team.
• Elixir-specific challenges during the development of the applications project with 2U.
• How Elixir’s failure-first programming capability ultimately helps developers.
• Sophie and Meryl’s experience using LiveView at Flatiron and the problems encountered.
• The work that went into preparing for training workshops.
• Advice for teaching someone who is not technical to become a working developer.
• Productivity hacks to stay focused and regain energy.
Links Mentioned in Today’s Episode:
Sophie DeBenedetto on LinkedIn — https://www.linkedin.com/in/sophiedebenedetto/
Sophie DeBenedetto on Twitter — https://twitter.com/sm_debenedetto
Meryl Dakin in LinkedIn — https://www.linkedin.com/in/meryldakin/
Meryl Dakin on Twitter — https://twitter.com/meryldakin
Eric Oestrich — https://oestrich.org
Frame.io — https://frame.io
GitHub — https://github.com
Flatiron School — https://flatironschool.com
Elixir — https://elixir-lang.org
React — https://reactjs.org
2U — https://2u.com
Kubernetes — https://kubernetes.io
Ruby — https://www.ruby-lang.org/en/
Elixir School — https://elixirschool.com/en/
Drawing on the Right Side of the Brain — https://www.amazon.com/Drawing-Right-Side-Brain-Definitive/dp/1585429201
Etsy — https://www.etsy.com
EMPEX NYC Conference — https://empex.co/nyc.html
SmartLogic — https://smartlogic.io/ Special Guests: Meryl Dakin and Sophie DeBenedetto.

Jan 23, 2020 • 39min
Brooklyn Zelenka on Functional Programming
In today’s episode we have one of our favorite recurring guests, Brooklyn Zelenka, joining us once again! Brooklyn has been on the show in both the first and second seasons to speak about Elixir and functional programming. In those conversations, it came up that this topic is far from exhausted, and since Season 3's theme is working with Elixir, we thought it would be great to have Brooklyn on for a third time. Today, Brooklyn does not speak to Elixir specifically though, but on functional programming more broadly. Fission, her company which is working on developing next-generation hostless apps, actually uses Haskel, but Brooklyn has a ton of experience across the board. She gives us some great insights into what makes the functional versus OOP paradigm great and helps us to understand some of the inner workings of both worlds, talking about abstraction, application, data orientation, and more. Interestingly, Brooklyn does employ some imperative programming in her company through the use of Typescript, but uses a functional style to get around the context switch. We spend some time toward the end of the show digging deeper into macros, and Brooklyn helps to revise understandings of them as code which writes more code as well as clarifies the term 'homoiconic' as it relates to ASTs. Brooklyn covers a whole lot more today so hop on for a deep dive into functional programming with today's great guest.
Key Points From This Episode:
• Why Brooklyn uses FPE: it can be reused and reasoned about.
• Two things that functions provide: abstraction and application.
• Data orientation and hiding information: imperative vs functional paradigms.
• Understanding imperative programming: it’s less structured and hard to reason about.
• Challenges experienced imperative programmers face with functional programming.
• Differences between Elixir, Erlang, Haskel, Elm, and Clojure.
• Using Clojure: tradeoffs, distinctions, tooling, flexibility, and compatibility with Java.
• The language Brooklyn could use if only one existed: Racket.
• Bridging functional and imperative paradigms through disciplined use of style.
• Segfaults in Haskell related to its compatibility with lib C.
• How to use Musl instead of lib C by employing docker files.
• Algebraic types and why static types aren’t hindrances in functional languages.
• Preferences for tests or proofs and their role in finding types valuable.
• Macros as compile-time functions that are difficult to debug.
• A definition of a ‘homoiconic’: high-level syntax which represents the AST.
• What makes C macros different from Lisp ones.
• Architecture in Elixir and the need for a more user-friendly Haskell.
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Brooklyn Zelenka on LinkedIn — https://www.linkedin.com/in/brooklynzelenka/
Fission — https://fission.codes/
Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X
Chris Keathley — https://keathley.io/
Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Paul Graham — http://www.paulgraham.com/Special Guest: Brooklyn Zelenka.

Jan 16, 2020 • 38min
Bruce and Maggie Tate from Groxio on Training
Groxio is a great platform that allows programmers to learn new languages easily and broaden their horizons. Our guests today are the team behind Groxio, Bruce and Maggie Tate! In our discussion, we cover the basics and the not so basics of what they do, from how they got into the Elixir world and founded Groxio to the conferences they run and the books they have published. We also talk about the benefits of learning multiple languages and Bruce makes a strong argument for the influence that smaller coding languages have had on his Elixir skills. Maggie and Bruce open up about having a professional and personal partnership and how they manage their marriage and businesses side by side. To finish off we hear about all the exciting things to expect at the Lonestar Conference this year and how it is going to be even better than last year's!
Key Points From This Episode:
• Bruce and Maggie's background in Elixir and how they started Groxio.
• What sets Groxio apart from similar technical education companies.
• The inspiration that Bruce got from the Crystal and Pony languages.
• How curiosity and dopamine are linked; following new and interesting pathways.
• Maggie and Bruce's personal and professional partnership and how they manage it.
• The Elixir books that still need to be written and under-appreciated published ones.
• A guide to Bruce's books and which to read for particular applications.
• Running a conference; the stressful and fun parts for Maggie and Bruce.
• Aspirations for the conferences and what to expect at this year's events.
• Exciting speakers that will be appearing at the Lone Star Conference.
• The controversy around the new Lone Star bat logo!
• A few special plugs from our guests for things they are passionate about.
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Bruce and Maggie Tate — https://grox.io/about
Bruce Tate on Twitter — https://twitter.com/redrapids
Maggie Tate on Twitter — https://twitter.com/gardenertate
Groxio — https://grox.io/
Gig City Elixir — https://www.gigcityelixir.com/
Lone Star Elixir — https://lonestarelixir.com/
Crystal — https://crystal-lang.org/
Pony — https://www.ponylang.io/
Joe Armstrong — https://joearms.github.io/
Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/161729201X
Designing Elixir Systems — https://www.amazon.com/Designing-Elixir-Systems-OTP-Self-healing/dp/1680506617/
Andrea Leopardi — https://confengine.com/user/andrea-leopardiSpecial Guests: Bruce Tate and Maggie Tate.

Jan 9, 2020 • 23min
Dan Ivovich from SmartLogic on Hiring and Training
On today's show, we are joined by Dan Ivovich from our team here at SmartLogic! Dan is the Director of Development Operations and has already been a guest and cohost a few times on the show. Today we are talking about hiring and training and his experience with these tasks at the company and especially concerning Elixir. We discuss the challenges Dan has faced in recruiting and the ways in which SmartLogic has lined up resumes and possible candidates through events and meetups. Dan explains some of the difficulties that are common for programmers transitioning into Elixir and how the company approaches the tasks of onboarding and ongoing support. We also get into Dan's favorite resources and tools for staying abreast of Elixir and his recommendations for practices to learn fast as a newcomer before he explains how he thinks about continual learning and expanding his own skillset. The conversation finishes with some thoughts and reflections on functional programming from our guest, so make sure to tune in for all of that and more!
Key Points From This Episode:
Dan's role at SmartLogic and how he leads the team.
Recruiting new employees; collecting resumes and attending events.
Challenges posed by recruiting good Elixir programmers and who to look for.
Sticking points for people transitioning into Elixir from other languages.
The stack at SmartLogic and the number of projects based in Elixir.
Onboarding at the company; skills that are transferable to Elixir.
Professional development and ongoing support for team members.
Dan's favorite tools and resources for learning Elixir.
Continual learning and Dan's strategies for growing his skillset.
A simple definition of functional programming and Dan's early experiences with it.
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Dan Ivovich — https://www.danivovich.com/
Dan Ivovich on Twitter — https://twitter.com/danivovich
ElixirConf — https://elixirconf.com/events
Java — https://www.java.com/
Ruby — https://www.ruby-lang.org/
Python — https://www.python.org/
Rails — https://rubyonrails.org/
Rust — https://www.rust-lang.org/
GO — https://golang.org/
Twitch — https://www.twitch.tv/
Bruce Tate — https://codesync.global/speaker/bruce-tate/
Scala — https://www.scala-lang.org/Special Guest: Dan Ivovich.

Jan 2, 2020 • 37min
Eric Meadows Jönsson on Hex and Working with Elixir
We are happy to be joined in this episode by Eric Meadows Jönsson, creator of the hexpm package manager, and an amazing resource who works tirelessly to build the Elixir community. Eric presently works at Brex and was part of the core team at Forza previously. In keeping with our current topic of all things working with Elixir, Eric takes a deep dive into the work he is doing to optimize various interfaces at Brex. He gives us the rundown on the static compile-time checking project he is working on, talking about his aims to build in different warnings and what we can expect from the new release in that regard. You’ll also hear about Eric’s journey learning Elixir and how he had to change his OOP mindset when he got introduced to functional programming at university. He shares the story behind hexpm and Mint, his thoughts about the future of Hex, and some of the processes around accessing the private repositories on its website. We also hear more about Eric’s hiring procedure while working at Forza, how he teaches functional programming to students at ElixirConf, and some of the major performance bottlenecks he experiences using Hex. Tap into the incredible resource that is Eric and hear more about how you can link with him online to learn further in the future by tuning in!
Key Points From This Episode:
Jose Valim, the Ecto library, and Eric’s journey with Elixir since 2012 at a coding camp.
Early-stage static compile-time checks that Eric is adding to the compiler at Brex.
Whether the static compile-time checks Eric is adding constitute a type system or not.
Static compile-time checks in the current system such as undefined function warnings.
Features of the new static compile-time check release: refactored checks, etc.
Currently, these checks happen at compile-time, or when Elixir compiles into the byte code.
Whether these checks will move into BEAM: currently it’s in Elixir and at an early stage.
The Erlang compiler already does type inference during compilation.
Eric’s Erlang proficiency and why he had to brush up on it through using Elixir.
What makes Eric helpful with Hex: his debugging skills and availability to answer questions.
How Eric got started with Hex adding an intake for Git packages.
The story behind Hex regarding ties to Elixir and Devinus from Pool Boy.
Todd’s perspective on Eric as a smart and nice mentor who sleeps very little.
Changes that Eric sees happening in Elixir.
Hex will no longer support older Elixir versions so that it can enable better maintenance.
Another change will be a refactoring of the resolution version algorithm.
Security-related updates that Todd has been working on.
Private versus public repositories on the hex.pm website.
Hiring challenges at Forza and how Eric found the right team out of scarce people.
Eric looks for people who love being programmers and have a passion for learning.
Tactics Eric uses to train functional programming such as hosting ElixirConf workshops.
Important fundamentals in functional programming: using data structures to model data, etc.
Differences between functional and object-oriented programming: data vs classes.
The role of types in Eric coming to understand functional programming better.
Performance bottlenecks in Hex such as dependency resolution.
How every package manager/resolver compromises, exemplified by NPM and Rebar3.
Origins of Mint: wanting http2 support for Hex, and more.
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Eric Meadows Jönsson on GitHub – https://github.com/ericmj
Eric Meadows Jönsson on Hexpm — https://hex.pm/users/ericmj
Brex — https://brex.com/
Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek
Justus Eapen on LinkedIn — https://www.linkedin.com/in/justuseapen/
Eric Oestreich on LinkedIn — https://www.linkedin.com/in/eric-oestreich-8b55aab/
hexpm on GitHub — https://github.com/hexpm
Google Summer of Code — https://summerofcode.withgoogle.com/
Jose Valim on GitHib — https://github.com/josevalim
Pool Boy — https://github.com/devinus/poolboy
Devin Alexander Torres — https://github.com/devinus
Voitech — https://www.voitech.biz/
Hex — https://hex.pm/
hexpm specifications — https://github.com/hexpm/specifications
Slack — https://slack.com
IRC —https://hexchat.github.io/
Forza — https://www.forzafootball.com/women
ElixirConf — https://elixirconf.com/events
Chalmers University — https://www.chalmers.se/en/Pages/default.aspx
Fastly — https://www.fastly.com/
NPM — https://www.npmjs.com/
Rebar 3 — https://github.com/erlang/rebar3
Mint — https://www.mint-lang.com/
Ruby Gems — https://rubygems.org/
Andrea Leopardi on GitHub — https://github.com/whatyouhide?tab=overview&org=ForzaElixirSpecial Guest: Todd Resudek.

Dec 19, 2019 • 35min
Chris Keathley on Performance and Functional Programming
Our guest on the show today is blogger, software cowboy, and podcast host Chris Keathley. Chris is a senior engineer at Bleacher Report, co-host of Elixir Outlaws, and writer of an assemblage of open-source software. He joins us today to speak about his new projects, his journey with functional programming, and what it is like to run Bleacher Report’s infrastructure on Elixir. Chris gives us the lowdown on Norm, a data validating interface he recently completed, weighing in on how it is different from Dialyzer and what it can offer as far as scalability. We hear more about how Chris got introduced to Elixir through Haskell, why he wishes he learned Clojure sooner, and why Ruby on Rails isn’t going anywhere soon.
Chris also gets into the tradeoffs these languages make to correlate with Erlang. He argues that Elixir can only be more widely adopted if more people build cool things in it, and then lays out some of its power in supporting Bleacher Report’s user interface. We pick Chris’s brain about what his company is trying to optimize at the moment and hear about their preference for capacity over speed, and their techniques for failing gracefully during traffic spikes. Chris tells us how much he loves Elixir due to its use of ETS and other functionality which allows Bleacher Report to keep running even above capacity. Finally, we hear about some of the observability practices that Bleacher Report uses when deploying new systems and predicting future spikes. Plug in for a great conversation and hear why you should get building with Elixir now!
Key Points From This Episode:
Chris’s explanation of Norm, his new software that describes data moving through a system.
Chris’s introduction to functional programming through learning Haskell, Clojure, and Elixir.
What makes a great functional language: immutable data and first class functions.
Things that make Clojure great, such as its thought out, holistic design.
Characteristics of Cons lists versus RRB trees, and what makes the latter better.
An acknowledgment of the necessity of the tradeoffs Elixir makes to interact with Erlang.
A little bit about the language Chris wrote to do the admin of code challenges in.
Why Ruby (on Rails) will not be replaced by Elixir due to commoditization that surrounds it.
An argument that Elixir can only be more widely adopted if more people build with it.
Why any language can build any program thus comparisons between them are arbitrary.
Where Chris sets the bar as to when something is performant.
Chris’s preference for high user capacity capability over speed of delivery at Bleacher Report.
Optimization projects at Bleacher Report such as using few boxes and handling traffic spikes.
Things Chris loves about Elixir such as its ability to deliver more from its boxes.
Elixir’s use of ETS and how Chris coded a complex problem in half a day using it.
How Chris detects spikes using time series, StatsD, and other observability tools.
Links Mentioned in Today’s Episode:
SmartLogic — https://smartlogic.io/
Chris Keathley on GitHub — https://github.com/keathley
Chris Keathley Blog — https://keathley.io/
ElixirConf 2019, Contracts for Building Reliable Systems presented by Chris Keathley — https://www.youtube.com/watch?v=tpo3JUyVIjQ
The Big Elixir 2019 - Keynote: Adoption - Brian Cardarella — https://www.youtube.com/watch?v=ghpIiQKRfQ4
Bleacher Report — https://bleacherreport.com/
Elixir Outlaws Podcast — https://elixiroutlaws.com/
Norm — https://github.com/keathley/norm
Dialyzer — http://erlang.org/doc/man/dialyzer.html
Haskell — https://www.haskell.org/
Clojure — https://clojure.org/
Erlang — https://www.erlang.org/
Chris Okasaki — https://github.com/chrisokasaki
Discord — https://discordapp.com/company
StatsD — https://www.datadoghq.com/blog/statsd/
Prometheus — https://prometheus.io/
Opentracing — https://opentracing.io/Special Guest: Chris Keathley.