Elixir Wizards

Latest Episodes:

Shanti Chellaram on Pri-Queue and raft_erl – Elixir Internals Sep 05, 2019

Show notes

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-495444187
Shanti Chellaram on Twitter — https://twitter.com/theccoder
Shanti Chellaram on github — https://github.com/shantiii
Erlang — https://www.erlang.org/
Elixir — https://elixir-lang.org/
Pri-Queue — https://github.com/okeuday/pqueue
raft_erl — https://github.com/shantiii/raft_erl
MailChimp — https://mailchimp.com
Teachers Pay Teachers — https://www.teacherspayteachers.com/
Purely Functional Data Structures — https://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki-ebook/dp/B00AKE1V04
Rust — https://www.rust-lang.org/
Raft — https://raft.github.io/
Raspberry Pi — https://www.raspberrypi.org/
ElixirConf — https://elixirconf.com/2019
Partisan — https://partisan.cloud/

Special Guests: Dan Ivovich and Shanti Chellaram.

Michał Muskała on Ecto and jason – Elixir Internals Aug 29, 2019

Show notes

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=en
Ecto — https://hexdocs.pm/ecto/Ecto.html
jason — https://github.com/michalmuskala/jason
Google 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.html
Atom VM — http://atomvm.sourceforge.net/

Special Guest: Michał Muskała.

Todd Resudek on Hex – Elixir Internals Aug 22, 2019

Show notes

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/alphabetify
ETS — 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/hex
Smart Software with SmartLogic — https://podcast.smartlogic.io/
Nerves MeetUp on Twitter — https://twitter.com/nervesmeetup
The Big Elixir — https://www.thebigelixir.com/

Special Guest: Todd Resudek.

Chris Keathley on Wallaby and Raft – Elixir Internals Aug 15, 2019

Show notes

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/keathley
Bleacher Report — https://bleacherreport.com/
Wallaby — https://hexdocs.pm/wallaby/Wallaby.html
Raft — 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.

René Föhring on Credo – Elixir Internals Aug 08, 2019

Show notes

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é Fö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é Föhring on Twitter — https://twitter.com/rrrene?lang=en
5 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/StyleCop
Dogma — https://github.com/lpil/dogma
Hex — https://hex.pm/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: René Föhring.

Meryl Dakin on Token Alchemist – Elixir Internals Aug 01, 2019

Show notes

Today on the show we continue our series on the inner workings of several different Elixir libraries and are happy to be joined by Meryl Dakin, Software Engineer at the Flatiron School and author of Token Alchemist. In this episode, we discover how Meryl got started with Elixir and what the process was like for her transitioning from Ruby to Elixir. We learn more about the internal functions of Token Alchemist within the school context and discuss the unique opportunities Meryl has discovered in Elixir, as well as the trickier language features that programmers are likely to experience in their learning process. Meryl also shares the challenges that Token Alchemist attempts to overcome – delving deeper into LTI, the Learn.co platform, OAuth and JSON. For all this and more, be sure to click play!

Key Points From This Episode:

Discover why Meryl first got started with Elixir.
Learn more about the Flatiron Bootcamp for coders.
Meryl’s experience in transitioning from Ruby to Elixir.
The opportunities for concurrency and fault tolerance in Elixir.
Discover the top three tricky language features in Elixir.
The benefits of going back to the basics of Elixir.
Find out the problems that Token Alchemist attempts to solve.
Meryl explains LTI and the Learn.co platform for students.
Learn more about custom parameters in Token Alchemist.
The process of learning OAuth in Token Alchemist.
What to consider when using LTI in Elixir.
The benefits of resource link history ID’s in the LTI spec.
Opportunities for you with Token Alchemist.
And much more!

Links Mentioned in Today’s Episode:

We Work — https://www.wework.com/
Flatiron School — https://flatironschool.com/
Elixir — https://elixir-lang.org/
Ruby — https://www.ruby-lang.org/en/
Learn.co — https://learn.co/
Meryl on LinkedIn — https://www.linkedin.com/in/meryldakin/
Meryl on Twitter — https://twitter.com/meryldakin
Meryl on GitHub — https://github.com/meryldakin
Token Alchemist on GitHub — https://github.com/meryldakin/token_alchemist

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Meryl Dakin.

Paul Schoenfelder on Distillery – Elixir Internals Jul 25, 2019

Show notes

Welcome back to show everyone and today in our exploration of Elixir libraries we are talking to Paul Schoenfelder! He is here to unpack Distillery, his own creation from the world of Elixir and tell us about how it works. We also discuss how Paul made the transition from bigger corporations into the startup world, his early experiences of different coding languages and the initial steps he took in writing Distillery. Paul is very honest about the unclear future of the library and he shares his hopes for it for the short term as well as clarifying its key concepts and functions. He gives great advice and directions for learning more about the resource and how you can help him and his projects out if you use them. For all this and then some, be sure to join us today for the show!

Key Points From This Episode:

Paul's work background, language history and the last few years working Elixir.
The first library that Paul contributed to and created on his own!
What brought about the creation of Distillery.
Clarifying releases, compiling, generating, deployment and more.
Where to learn more and find out details about the library.
The first steps Paul took when writing this latest version of the Distillery.
Looking to the future of Distillery and its current best use cases.
Hot upgrades and who they can be useful to when it comes to Elixir.
Let Paul know if you are using or want to contribute to a project of his!
And much more!

Links Mentioned in Today’s Episode:
Smartlogic — https://www.smartlogic.io/
Paul Schoenfelder — https://github.com/bitwalker
Bitwalker — http://bitwalker.org/
Distillery — https://hex.pm/packages/distillery
DockYard — https://dockyard.com/
Erlang — https://www.erlang.org/
Phoenix — https://phoenixframework.org/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Paul Schoenfelder.

Bryan Joseph on ElixirScript – Elixir Internals Jul 18, 2019

Show notes

Today on the show we continue our series on the inner workings and various libraries of Elixir and are very happy to welcome Bryan Joseph of Revelry to talk about his very own ElixirScript. ElixirScript is essentially an Elixir to JavaScript compiler, allowing users to run Elixir online more easily. We ask Bryan what inspired this project and about some of the major challenges that have faced it. We also talk about the role of his company, Revelry in his career and work in open source. Bryan tells us about his very own conference, The Big Elixir and why you should be traveling to New Orleans to check it out! Other topics covered include the architecture of ElixirScript, binary pattern matching, Bryan's other experiences of libraries and his hopes for ElixirScript's future. For all this and then some, be sure to listen in today!

Key Points From This Episode:

Some background on Bryan, his work and how he got started with Elixir.
What is ElixirScript? What does it do? How Brian got the idea!
ElixirScript's architecture; the inner workings of the compiler.
The major problems and challenges that face this task with JavaScript.
Step one in the process; the conversion of concepts.
Binary pattern matching and the implementation of strings.
The things Bryan would do differently looking back on the product.
Bryan's other experiences of libraries, contributions and fixes.
Marketing, posting and getting the word out on ElixirScript.
The current state of the project and hopes for the future.
A little bit about The Big Elixir and what sets it apart from other conferences.
And much more!

Links Mentioned in Today’s Episode:

Smartlogic — https://www.smartlogic.io/
ElixirScript — https://elixirscript.github.io/
Bryan Joseph — https://github.com/bryanjos
Revelry — https://revelry.co/
The Big Elixir— https://www.thebigelixir.com/
Metaprogramming Elixir — https://www.amazon.com/Metaprogramming-Elixir-Write-Less-Code/dp/1680500414
Chris McCord — http://chrismccord.com/
Erlang — https://www.erlang.org/
ElixirCon — https://www.elixirlabs.net/events/elixircon-2018
Lonestar Elixir — https://www.lonestarelixir.com/
Operation Spark — https://operationspark.org/
Flatiron — https://flatironschool.com/

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Bryan Joseph.

Brooklyn Zelenka on Witchcraft - Elixir Internals Jul 11, 2019

Show notes

Hey everybody and welcome back to Season 2 of the podcast! This season we will be talking about Elixir internals, libraries and the inner workings of the language. In our first episode we are very happy to be joined by Brooklyn Zelenka to start off our journey on the subject with an exploration of her very own Witchcraft.

In this episode we talk to Brooklyn about her history with Elixir, how she got started and what attracts her to it. Brooklyn explains the influence that open source philosophy has had on her career in developing and from there she gives a pretty comprehensive introduction to what Witchcraft is, expanding its key concepts. Although this is quite a high level discussion about Elixir and Witchcraft, we are confident that with Brooklyn's expert help even our most uninitiated listener can get some benefit from our conversation. We also talk about type systems, property-based checking and Dialyzer, so for all of this and more make sure to join us as we kick things off for Season 2!

Key Points From This Episode:

A quick introduction to Brooklyn, where she works and how she got started with Elixir.
The influence of open source and library contributions on Brooklyn's development.
Getting to grips with Witchcraft; defining monads and functors.
Why some of these scary terms do not need to frighten you.
A few little things that differentiate Witchcraft and some surprising elements.
The convenient guarantees that Witchcraft provides around your data structure.
Why there is no type system baked into Elixir; overheads, inputs and outputs.
Property-based checking and compile times in Witchcraft.
Merging of Elixir and Dialyzer; benefits and problems.
Getting in touch with Brooklyn and getting involved with Witchcraft and Elixir.
And much more!

Links Mentioned in Today’s Episode:

Smartlogic — https://www.smartlogic.io/
Brooklyn Zelenka — https://github.com/expede
Brooklyn Zelenka on Twitter — https://twitter.com/expede
Brooklyn Zelenka Email — hello@brooklynzelenka.com
Elixir — https://elixir-lang.org/
Witchcraft — https://hex.pm/packages/witchcraft
Dialyzer — https://github.com/jeremyjh/dialyxir

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Brooklyn Zelenka.

Elixir in Production Recap Apr 18, 2019

Show notes

With this season over, we bring Dan Ivovich back to talk about what we learned.

Dan Ivovich - Director of Development Operations @ SmartLogic

00:43 - Why are you using Elixir in production?
01:20 - Advantages / disadvantages of Elixir
02:38 - How do you deploy?
03:48 - Zero downtime deploys
05:40 - Clustering
06:56 - Elixir App performance
09:00 - Background task processing
10:36 - Common Libraries
14:40 - 3rd Party Services
16:16 - Do you have a story where Elixir saved the day in production?
17:56 - OTP features
18:31 - Tip to developers

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Dan Ivovich.

Our TOPPODCAST Picks

Follow Us

Stay Connected

Related Podcasts

Links

Stay Connected