Elixir Wizards

Latest Episodes:

Eric Meadows Jönsson on Hex and Working with Elixir Jan 02, 2020

Show notes

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 Jönsson on GitHub – https://github.com/ericmj
Eric Meadows Jö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=ForzaElixir

Special Guest: Todd Resudek.

Chris Keathley on Performance and Functional Programming Dec 19, 2019

Show notes

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.

Justin Schneck & Frank Hunleth on Nerves and Performance – Working with Elixir Dec 12, 2019

Show notes

On today’s show, we welcome Justin Schneck and Frank Hunleth, luminaries from the Nerves team! We take a dive into the world of Nerves with them, covering themes of performance, problem-solving, transitioning to hardware, and breakthroughs in the field. We begin with a conversation on how Elixir handles performance issues on the range of devices they support and Frank gets into how the team solved an early boot time discrepancy between a PC and a Raspberry Pi board. Other big themes for today are ironing out the kinks in the system registry model and merging Erlang and into hard real-time. After squeezing some information out of the guys about their use of ugly code hacks we get into some visionary decisions as well as things the team wished they could have done differently at Elixir (see the release of the new networking stack). Finally, we end off with what Frank and Justin are excited about as far as developments in the Nerves community, so be sure to plug into this one!

**Key Points From This Episode:

What Justin did in Tokyo, from soaking in hot springs to debugging in Kanji.
An explanation of The Erlang Ecosystem Foundation, an embedded systems working group.
The use of the VintageNet library for setting up multi-hold nerve networks.
How Elixir handles performance issues on the range of devices they support.
A breakdown of troubleshooting processes as far as acceleration with FPGAs.
Issues with dependencies that occur when starting a network node on a Nerves device.
How Elixir is trying to evolve past the system registry model.
Identifying the challenge of reconfiguring early boot time which Elixir is facing.
How Elixir solved a load time discrepancy between a PC and the Raspberry Pi board.
Which situations require hardware when Elixir is too slow, such as video encoding.
Japanese research into GPU, FPGA and SIMD optimization involving wrapping code blocks.
Merging Erlang which is soft real-time into hard real-time.
Examples of ugly but fast code hacks in Elixir.
Hacks and the pitfalls of system registry such as returning to a prompt when an app crashes.
Things Elixir would have done differently in working with Nerves if could they rewind time.
Why releasing a new networking stack means Elixir could have done things differently.
Lessons Justin and Frank learned moving from OTP to functional programming at Elixir.
Exciting new developments and releases in the Nerves community.

Links Mentioned in Today’s Episode:

Nerves Project — https://nerves-project.org/
SmartLogic — https://smartlogic.io/
ElixirConf US — https://elixirconf.com/events
The Erlang Ecosystem Foundation — https://erlef.org/
GRiSP — https://www.grisp.org/
Vintage Net — https://github.com/nerves-networking/vintage_net
Joe Armstrong — https://joearms.github.io/
Erlang — https://www.erlang.org/
Linux — https://www.linux.org/

Special Guest: Frank Hunleth.

Brad Traylor of Podium on Training & Hiring – Working with Elixir Dec 05, 2019

Show notes

Our theme this season is working with Elixir, and joining in the conversation today is Brad Traylor from Podium. Brad shares his expertise in hiring and training for Podium, a position he is passionate about since it gives him the opportunity to work on the people and tech side of things. We begin by hearing a bit of Brad’s background, when and how he was first introduced to Elixir and the standout qualities that attracted him to Podium. He discusses the hiring process, including what he looks for in an engineer, why they don’t recruit much but rather work with referrals, the step-by-step of onboarding new devs and the resources he recommends to anyone in the industry. Another great talk with a stand-up guy — be sure to tune in!

Key Points From This Episode:

When Brad was first exposed to Elixir and how he became the engineering manager.
Searching for rocket ship startups and what specifically drew him to Podium.
Having a desire to work with the people and the tech side of the industry.
The growth trajectory of Podium from a management perspective.
Hiring predominantly from referrals rather than recruiting developers.
The biggest challenge with hiring Elixir devs, including the scarcity of good ones!
Two things Brad looks for when hiring engineers: the drive to learn and a cultural fit.
The benefit of hiring younger developers.
Thoughts on training different languages and adding them to Podium’s tech stack.
An overview of the typical onboarding process for a new engineer.
Elixir 101 and other ways they keep training and refining the skills of developers.
Resources that Brad has recently learned and those he always recommends to devs.

**Links Mentioned in Today’s Episode:

Brad Traylor on LinkedIn — https://www.linkedin.com/in/bradtraylor
Brad Traylor on Twitter — https://twitter.com/btjordan23
Podium — https://www.podium.com
SmartLogic — https://smartlogic.io/
Elixir — https://elixir-lang.org
University of Michigan — https://umich.edu
Java — https://www.java.com/en/
Python — https://www.python.org
Rust — https://www.rust-lang.org
Ruby — https://www.ruby-lang.org/en/
TypeScript — https://www.typescriptlang.org
Pragmatic Institute — https://www.pragmaticinstitute.com/courses
The Manager’s Path — https://www.amazon.com/Managers-Path-Leaders-Navigating-Growth-ebook/dp/B06XP3GJ7F
Camile Fournier — https://twitter.com/skamille

Special Guest: Brad Traylor.

José Valim, Creator of Elixir Nov 26, 2019

Show notes

Today on Elixir Wizards we are joined by none other than José Valim, the inventor of Elixir! Coming from the Ruby on Rails world, José found his way to functional programming and we hear all about the evolution of his philosophy and thought process around the time of the creation of the language. He gives us some great insight into why functional programming is so appealing to him and the problems he wanted to solve by creating Elixir. We chat about other languages and his use of Erlang, Elixir's three biggest influences and some important characters in the story. José also shares a bit of personal, behind the scenes stuff about his schedule and how he tries to stay as productive as possible. We finish off the chat, talking about performance and the measures José has taken in this regard. For all this and more from a true Elixir wizard, be sure to tune in!

Key Points From This Episode:

José's thoughts on our recent podcast name-change!
The first steps for José in the process of writing a language.
Reason for José's decision to step out of the Ruby on Rails world.
The 'aha' moment that José had when moving into functional programming.
Some of the inspiration for Elixir from other languages.
A few of the people that have mentored and inspired José in his career.
The research and development phase for Elixir and José strategy for this.
José's work habits, his typical day and the influence of his kids on his flow.
Why José still considers himself an Elixir programmer despite his proximity.
Elixir and machine learning; why the two are not more closely linked.
Steps in the measurement process for José and Elixir.
The time that José has spent on the performance side of the language.
Sacrifices and substitution in optimizing Elixir's performance.
Some of the things on the horizon that are exciting José.

Links Mentioned in Today’s Episode:

SmartLogic
José Valim
Plataformatec
Harry Potter
Erlang
Ruby
Clojure
ElixirConf

Special Guest: José Valim.

Dr Jim Freeze on Hiring, Training, and Functional Programming – Working with Elixir Nov 21, 2019

Show notes

Welcome to Elixir Wizards, today we are joined by Dr. Jim Freeze to talk about his passion for and history in Elixir and functional programming. Dr. Freeze is one of the organizers of one of our favorite things in the world, Elixir Conf! He shares his story of coming to functional programming and his early days with Elixir, what he sees as the most important aspects of the conference before diving into what is on offer for those that attend. We talk about how employers can get Elixir newcomers up to speed on the language and the most effective ways Dr. Freeze stays abreast of developments in the field. Our guest also recommends a few resources for those wanting an introduction to Elixir and makes a great argument for the usefulness of a functional approach to programming. For all this and a whole bunch more, join us today!

Key Points From This Episode:

How Dr. Freeze got started with Elixir and his programming background.
A little bit about the early days of Elixir Conf and what the first events were like.
The particulars of Dr. Freeze's doctorate and his title.
Education, networking and how Elixir Conf fits into the developer hiring game.
The training that is offered at the conference and the philosophy to serving attendees.
Dr. Freeze's recommendations for employers bringing newbies up to speed with Elixir.
How our guest continues his learning and stays focused on what is necessary.
Useful resources and materials for Elixir, according to Dr. Freeze.
Contemplating functional programming and its key components.
Why to consider functional programming coming from an object-based background.
The biggest hurdles in moving over to functional programming and Elixir.
Following the data and how much the simplicity of this directive can help.
Dr. Freeze's favorite thing in the functional world!

Links Mentioned in Today’s Episode:
SmartLogic
Dr. Jim Freeze on Twitter
ElixirConf
Sophie DeBenedetto
Elixir Radar
Phoenix In Action
Geoffrey Lessel
Saša Jurić
Sandi Metz

Special Guest: Dr. Jim Freeze.

Season Two Wrap Oct 03, 2019

Show notes

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/expede
Bryan Joseph — https://github.com/bryanjos
Paul Schoenfelder — https://github.com/bitwalker
Meryl Dakin— https://github.com/meryldakin
René Föhring— https://twitter.com/rrrene
Michal Muskala — https://michal.muskala.eu/
Todd Resudek — https://www.linkedin.com/in/toddresudek/
Shanti Chellaram— https://github.com/shantiii
Sophie DeBenedetto — http://sophiedebenedetto.nyc/
Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b
ElixirConf — https://elixirconf.com/2019
The Big Elixir — https://www.thebigelixir.com/
Le Petit Theatre — http://www.lepetittheatre.com
Lone Star Elixir — https://www.lonestarelixir.com
The Empire Strikes Back — https://www.rottentomatoes.com/m/empire_strikes_back

Dave Lucia on Rustler – Elixir Internals Sep 26, 2019

Show notes

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-a395441b
Rustler — https://github.com/rusterlium/rustler
SimpleBet — https://simplebet.io
Dave Lucia on Twitter — https://twitter.com/davydog187
Dave Lucia Email — dave@simplebet.io
Elixir — https://elixir-lang.org
Python — https://www.python.org
JavaScript — https://www.javascript.com
Rust — https://www.rust-lang.org
Bloomberg — https://www.bloomberg.com
Slack — https://slack.com
Vox Media — https://www.voxmedia.com
The Outline — https://theoutline.com
The Rust Programming Language — https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284
Rust Playground — https://play.rust-lang.org
Elm Compiler — https://github.com/elm/compiler

Special Guest: Dave Lucia.

Eric Oestrich on ExVenture – Elixir Internals Sep 19, 2019

Show notes

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/MUD
Ecto - https://github.com/elixir-ecto/ecto
Eric's Going Multi-Node presentation at ElixirConf - https://www.youtube.com/watch?v=lCUKQnkjajo
The Big Elixir - https://www.thebigelixir.com/
Eric's Prometheus presentation at Lonestar Elixir - https://www.youtube.com/watch?v=ETUD9SaRCjY
Prometheus - 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.

Sophie DeBenedetto on Excrypt and Railway – Elixir Internals Sep 12, 2019

Show notes

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/encrypt
Escript — https://hexdocs.pm/mix/master/Mix.Tasks.Escript.Build.html
Ruby — https://www.ruby-lang.org/en/
Kafka — https://kafka.apache.org
Ecto — https://hexdocs.pm/ecto/Ecto.html
Erlang — https://www.erlang.org
RabbitMQ — https://www.rabbitmq.com
Phoenix — https://phoenixframework.org
LiveView — https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascript
Elixir Conf — https://elixirconf.com/2019

Special Guest: Sophie DeBenedetto.

Our TOPPODCAST Picks

Follow Us

Stay Connected

Related Podcasts

Links

Stay Connected