Elixir Wizards is an interview-format podcast, focused on engineers who use the Elixir programming language. Initially launched in early 2019, each season focuses on a specific topic or topics, with each interview focusing on the guest's experience and opinions on the topic. Elixir Wizards is hosted by Eric Oestrich and Sundi Myint of SmartLogic, a dev shop that’s been building custom software since 2005 and running Elixir applications in production since 2015. Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
Similar Podcasts
Flutter 101 Podcast
Weekly podcast focusing on software development with Flutter and Dart. Hosted by Vince Varga.
Elixir Outlaws
Elixir Outlaws is an informal discussion about interesting things happening in Elixir. Our goal is to capture the spirit of a conference hallway discussion in a podcast.
Remote Ruby
Three Rubyists having conversations and interviewing others about Ruby and web development.
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.
Justin Schneck & Frank Hunleth on Nerves and Performance – Working with Elixir
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
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
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 (https://www.smartlogic.com) José Valim (https://github.com/josevalim) Plataformatec (http://plataformatec) Harry Potter (https://www.wizardingworld.com/) Erlang (https://www.erlang.org/) Ruby (https://www.ruby-lang.org/en/) Clojure (https://clojure.org/) ElixirConf (https://elixirconf.com/events) Special Guest: José Valim.
Dr Jim Freeze on Hiring, Training, and Functional Programming – Working with Elixir
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 (https://www.smartlogic.com) Dr. Jim Freeze on Twitter (https://twitter.com/jimfreeze) ElixirConf (https://elixirconf.com/events) Sophie DeBenedetto (http://sophiedebenedetto.nyc/) Elixir Radar (https://elixirnation.io/references/elixir-radar-weekly-newsletter-on-elixir) Phoenix In Action (https://www.amazon.com/Phoenix-Action-Geoffrey-Lessel/dp/1617295043) Geoffrey Lessel (http://www.apple.com) Saša Jurić (https://codesync.global/speaker/sasa-juric/) Sandi Metz (https://www.sandimetz.com) Special Guest: Dr. Jim Freeze.
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.
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/expede Bryan Joseph — https://github.com/bryanjos Paul Schoenfelder — https://github.com/bitwalker Meryl Dakin— https://github.com/meryldakin René Fö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/empirestrikesback
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-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
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. (https://smr.tl/2Hyslu8)
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/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.
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 rafterl, 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 rafterl, 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 rafterl — https://github.com/shantiii/rafterl 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
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
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
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
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=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. (https://smr.tl/2Hyslu8) Special Guest: René Föhring.